---
source: crates/ruff_python_parser/tests/fixtures.rs
input_file: crates/ruff_python_parser/resources/valid/expressions/bin_op.py
---
## AST

```
Module(
    ModModule {
        node_index: AtomicNodeIndex(..),
        range: 0..397,
        body: [
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 9..14,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 9..14,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 9..10,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: Add,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 13..14,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 15..20,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 15..20,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 15..16,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: Sub,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 19..20,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 21..26,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 21..26,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 21..22,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: Mult,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 25..26,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 27..32,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 27..32,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 27..28,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: Div,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 31..32,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 33..39,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 33..39,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 33..34,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: FloorDiv,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 38..39,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 40..45,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 40..45,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 40..41,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: Mod,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 44..45,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 46..52,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 46..52,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 46..47,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: Pow,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 51..52,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 53..58,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 53..58,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 53..54,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: BitOr,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 57..58,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 59..64,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 59..64,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 59..60,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: BitXor,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 63..64,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 65..70,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 65..70,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 65..66,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: BitAnd,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 69..70,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 71..77,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 71..77,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 71..72,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: RShift,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 76..77,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 78..84,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 78..84,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 78..79,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: LShift,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 83..84,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 85..90,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 85..90,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 85..86,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: MatMult,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 89..90,
                                    value: Int(
                                        2,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 110..123,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 110..123,
                            left: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 110..119,
                                    left: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 110..115,
                                            left: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 110..111,
                                                    value: Int(
                                                        1,
                                                    ),
                                                },
                                            ),
                                            op: Add,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 114..115,
                                                    value: Int(
                                                        2,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                    op: Sub,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 118..119,
                                            value: Int(
                                                3,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Add,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 122..123,
                                    value: Int(
                                        4,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 124..146,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 124..146,
                            left: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 124..142,
                                    left: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 124..138,
                                            left: BinOp(
                                                ExprBinOp {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 124..133,
                                                    left: BinOp(
                                                        ExprBinOp {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 124..129,
                                                            left: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 124..125,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                            op: Mult,
                                                            right: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 128..129,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    op: Div,
                                                    right: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 132..133,
                                                            value: Int(
                                                                3,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                            op: FloorDiv,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 137..138,
                                                    value: Int(
                                                        4,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                    op: MatMult,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 141..142,
                                            value: Int(
                                                5,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Mod,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 145..146,
                                    value: Int(
                                        6,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 147..168,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 147..168,
                            left: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 147..163,
                                    left: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 147..158,
                                            left: BinOp(
                                                ExprBinOp {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 147..153,
                                                    left: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 147..148,
                                                            value: Int(
                                                                1,
                                                            ),
                                                        },
                                                    ),
                                                    op: LShift,
                                                    right: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 152..153,
                                                            value: Int(
                                                                2,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                            op: RShift,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 157..158,
                                                    value: Int(
                                                        3,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                    op: RShift,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 162..163,
                                            value: Int(
                                                4,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: LShift,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 167..168,
                                    value: Int(
                                        5,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 193..202,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 193..202,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 193..194,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: Add,
                            right: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 197..202,
                                    left: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 197..198,
                                            value: Int(
                                                2,
                                            ),
                                        },
                                    ),
                                    op: Mult,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 201..202,
                                            value: Int(
                                                3,
                                            ),
                                        },
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 203..212,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 203..212,
                            left: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 203..208,
                                    left: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 203..204,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                    op: Mult,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 207..208,
                                            value: Int(
                                                2,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Add,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 211..212,
                                    value: Int(
                                        3,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 213..244,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 213..244,
                            left: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 213..235,
                                    left: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 213..231,
                                            left: BinOp(
                                                ExprBinOp {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 213..223,
                                                    left: BinOp(
                                                        ExprBinOp {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 213..219,
                                                            left: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 213..214,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                            op: Pow,
                                                            right: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 218..219,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    op: Mult,
                                                    right: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 222..223,
                                                            value: Int(
                                                                3,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                            op: Sub,
                                            right: BinOp(
                                                ExprBinOp {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 226..231,
                                                    left: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 226..227,
                                                            value: Int(
                                                                4,
                                                            ),
                                                        },
                                                    ),
                                                    op: MatMult,
                                                    right: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 230..231,
                                                            value: Int(
                                                                5,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                    op: Add,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 234..235,
                                            value: Int(
                                                6,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Sub,
                            right: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 238..244,
                                    left: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 238..239,
                                            value: Int(
                                                7,
                                            ),
                                        },
                                    ),
                                    op: FloorDiv,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 243..244,
                                            value: Int(
                                                8,
                                            ),
                                        },
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 270..306,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 270..306,
                            left: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 270..271,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                            op: BitOr,
                            right: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 274..306,
                                    left: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 274..279,
                                            left: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 274..275,
                                                    value: Int(
                                                        2,
                                                    ),
                                                },
                                            ),
                                            op: BitAnd,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 278..279,
                                                    value: Int(
                                                        3,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                    op: BitXor,
                                    right: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 282..306,
                                            left: BinOp(
                                                ExprBinOp {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 282..301,
                                                    left: BinOp(
                                                        ExprBinOp {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 282..291,
                                                            left: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 282..283,
                                                                    value: Int(
                                                                        4,
                                                                    ),
                                                                },
                                                            ),
                                                            op: Add,
                                                            right: BinOp(
                                                                ExprBinOp {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 286..291,
                                                                    left: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: AtomicNodeIndex(..),
                                                                            range: 286..287,
                                                                            value: Int(
                                                                                5,
                                                                            ),
                                                                        },
                                                                    ),
                                                                    op: MatMult,
                                                                    right: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: AtomicNodeIndex(..),
                                                                            range: 290..291,
                                                                            value: Int(
                                                                                6,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    op: LShift,
                                                    right: BinOp(
                                                        ExprBinOp {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 295..301,
                                                            left: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 295..296,
                                                                    value: Int(
                                                                        7,
                                                                    ),
                                                                },
                                                            ),
                                                            op: FloorDiv,
                                                            right: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: AtomicNodeIndex(..),
                                                                    range: 300..301,
                                                                    value: Int(
                                                                        8,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                            op: RShift,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 305..306,
                                                    value: Int(
                                                        9,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 324..339,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 324..339,
                            left: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 324..335,
                                    left: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 324..325,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                    op: Add,
                                    right: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 329..334,
                                            left: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 329..330,
                                                    value: Int(
                                                        2,
                                                    ),
                                                },
                                            ),
                                            op: Add,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 333..334,
                                                    value: Int(
                                                        3,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Add,
                            right: NumberLiteral(
                                ExprNumberLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 338..339,
                                    value: Int(
                                        4,
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 340..359,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 340..359,
                            left: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 340..345,
                                    left: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 340..341,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                    op: Add,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 344..345,
                                            value: Int(
                                                2,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Add,
                            right: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 349..358,
                                    left: BinOp(
                                        ExprBinOp {
                                            node_index: AtomicNodeIndex(..),
                                            range: 349..354,
                                            left: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 349..350,
                                                    value: Int(
                                                        3,
                                                    ),
                                                },
                                            ),
                                            op: Add,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 353..354,
                                                    value: Int(
                                                        4,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                    op: Add,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 357..358,
                                            value: Int(
                                                5,
                                            ),
                                        },
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 390..396,
                    value: BinOp(
                        ExprBinOp {
                            node_index: AtomicNodeIndex(..),
                            range: 390..396,
                            left: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 390..391,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            op: Add,
                            right: UnaryOp(
                                ExprUnaryOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 393..396,
                                    op: UAdd,
                                    operand: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 395..396,
                                            id: Name("y"),
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                        },
                    ),
                },
            ),
        ],
    },
)
```
