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

```
Module(
    ModModule {
        range: 0..5743,
        body: [
            Match(
                StmtMatch {
                    range: 67..103,
                    subject: Name(
                        ExprName {
                            range: 73..74,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 80..103,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 85..88,
                                    value: UnaryOp(
                                        ExprUnaryOp {
                                            range: 85..88,
                                            op: USub,
                                            operand: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 86..88,
                                                    value: Complex {
                                                        real: 0.0,
                                                        imag: 0.0,
                                                    },
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 98..103,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 98..99,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 102..103,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 126..167,
                    subject: Name(
                        ExprName {
                            range: 132..133,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 139..167,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 144..152,
                                    cls: Name(
                                        ExprName {
                                            range: 144..149,
                                            id: "bytes",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 149..152,
                                        patterns: [
                                            MatchAs(
                                                PatternMatchAs {
                                                    range: 150..151,
                                                    pattern: None,
                                                    name: Some(
                                                        Identifier {
                                                            id: "z",
                                                            range: 150..151,
                                                        },
                                                    ),
                                                },
                                            ),
                                        ],
                                        keywords: [],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 162..167,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 162..163,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 166..167,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 190..260,
                    subject: Name(
                        ExprName {
                            range: 196..197,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 203..229,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 208..209,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 208..209,
                                            value: Int(
                                                0,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: Some(
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 213..214,
                                        value: Int(
                                            0,
                                        ),
                                    },
                                ),
                            ),
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 224..229,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 224..225,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 228..229,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 234..260,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 239..240,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 239..240,
                                            value: Int(
                                                0,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: Some(
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 244..245,
                                        value: Int(
                                            1,
                                        ),
                                    },
                                ),
                            ),
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 255..260,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 255..256,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 259..260,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 283..332,
                    subject: NumberLiteral(
                        ExprNumberLiteral {
                            range: 289..290,
                            value: Int(
                                3,
                            ),
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 296..332,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 301..314,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 301..302,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 301..302,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 305..306,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 305..306,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 309..310,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 309..310,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 313..314,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 313..314,
                                                        value: Int(
                                                            3,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 324..332,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 324..325,
                                                    id: "x",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: BooleanLiteral(
                                            ExprBooleanLiteral {
                                                range: 328..332,
                                                value: true,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 355..403,
                    subject: Name(
                        ExprName {
                            range: 361..362,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 368..403,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 373..388,
                                    patterns: [
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 373..379,
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 374..375,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 374..375,
                                                                    value: Int(
                                                                        0,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 377..378,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 377..378,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 382..388,
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 383..384,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 383..384,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 386..387,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 386..387,
                                                                    value: Int(
                                                                        0,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 398..403,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 398..399,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 402..403,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 445..523,
                    subject: Name(
                        ExprName {
                            range: 451..452,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 458..489,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 463..467,
                                    patterns: [
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 464..466,
                                                name: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Return(
                                    StmtReturn {
                                        range: 477..489,
                                        value: Some(
                                            StringLiteral(
                                                ExprStringLiteral {
                                                    range: 484..489,
                                                    value: StringLiteralValue {
                                                        inner: Single(
                                                            StringLiteral {
                                                                range: 484..489,
                                                                value: "seq",
                                                                flags: StringLiteralFlags {
                                                                    quote_style: Double,
                                                                    prefix: Empty,
                                                                    triple_quoted: false,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                },
                                            ),
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 494..523,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 499..501,
                                    keys: [],
                                    patterns: [],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Return(
                                    StmtReturn {
                                        range: 511..523,
                                        value: Some(
                                            StringLiteral(
                                                ExprStringLiteral {
                                                    range: 518..523,
                                                    value: StringLiteralValue {
                                                        inner: Single(
                                                            StringLiteral {
                                                                range: 518..523,
                                                                value: "map",
                                                                flags: StringLiteralFlags {
                                                                    quote_style: Double,
                                                                    prefix: Empty,
                                                                    triple_quoted: false,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                },
                                            ),
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 546..714,
                    subject: Name(
                        ExprName {
                            range: 552..553,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 559..594,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 564..579,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 565..566,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 568..578,
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 569..570,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 569..570,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 572..573,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 572..573,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchMapping(
                                                        PatternMatchMapping {
                                                            range: 575..577,
                                                            keys: [],
                                                            patterns: [],
                                                            rest: None,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 589..594,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 589..590,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 593..594,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 599..687,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 604..672,
                                    patterns: [
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 604..626,
                                                keys: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 605..606,
                                                            value: Int(
                                                                0,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchOr(
                                                        PatternMatchOr {
                                                            range: 608..625,
                                                            patterns: [
                                                                MatchSequence(
                                                                    PatternMatchSequence {
                                                                        range: 608..618,
                                                                        patterns: [
                                                                            MatchValue(
                                                                                PatternMatchValue {
                                                                                    range: 609..610,
                                                                                    value: NumberLiteral(
                                                                                        ExprNumberLiteral {
                                                                                            range: 609..610,
                                                                                            value: Int(
                                                                                                1,
                                                                                            ),
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                            MatchValue(
                                                                                PatternMatchValue {
                                                                                    range: 612..613,
                                                                                    value: NumberLiteral(
                                                                                        ExprNumberLiteral {
                                                                                            range: 612..613,
                                                                                            value: Int(
                                                                                                2,
                                                                                            ),
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                            MatchMapping(
                                                                                PatternMatchMapping {
                                                                                    range: 615..617,
                                                                                    keys: [],
                                                                                    patterns: [],
                                                                                    rest: None,
                                                                                },
                                                                            ),
                                                                        ],
                                                                    },
                                                                ),
                                                                MatchSingleton(
                                                                    PatternMatchSingleton {
                                                                        range: 621..625,
                                                                        value: True,
                                                                    },
                                                                ),
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 629..638,
                                                keys: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 630..631,
                                                            value: Int(
                                                                1,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchSequence(
                                                        PatternMatchSequence {
                                                            range: 633..637,
                                                            patterns: [
                                                                MatchSequence(
                                                                    PatternMatchSequence {
                                                                        range: 634..636,
                                                                        patterns: [],
                                                                    },
                                                                ),
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 641..656,
                                                keys: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 642..643,
                                                            value: Int(
                                                                0,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchSequence(
                                                        PatternMatchSequence {
                                                            range: 645..655,
                                                            patterns: [
                                                                MatchValue(
                                                                    PatternMatchValue {
                                                                        range: 646..647,
                                                                        value: NumberLiteral(
                                                                            ExprNumberLiteral {
                                                                                range: 646..647,
                                                                                value: Int(
                                                                                    1,
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                MatchValue(
                                                                    PatternMatchValue {
                                                                        range: 649..650,
                                                                        value: NumberLiteral(
                                                                            ExprNumberLiteral {
                                                                                range: 649..650,
                                                                                value: Int(
                                                                                    2,
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                MatchMapping(
                                                                    PatternMatchMapping {
                                                                        range: 652..654,
                                                                        keys: [],
                                                                        patterns: [],
                                                                        rest: None,
                                                                    },
                                                                ),
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 659..661,
                                                patterns: [],
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 664..667,
                                                value: StringLiteral(
                                                    ExprStringLiteral {
                                                        range: 664..667,
                                                        value: StringLiteralValue {
                                                            inner: Single(
                                                                StringLiteral {
                                                                    range: 664..667,
                                                                    value: "X",
                                                                    flags: StringLiteralFlags {
                                                                        quote_style: Double,
                                                                        prefix: Empty,
                                                                        triple_quoted: false,
                                                                    },
                                                                },
                                                            ),
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 670..672,
                                                keys: [],
                                                patterns: [],
                                                rest: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 682..687,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 682..683,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 686..687,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 692..714,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 697..699,
                                    patterns: [],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 709..714,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 709..710,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 713..714,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 737..782,
                    subject: Name(
                        ExprName {
                            range: 743..744,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 750..782,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 755..767,
                                    value: BinOp(
                                        ExprBinOp {
                                            range: 755..767,
                                            left: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 755..759,
                                                    value: Float(
                                                        0.25,
                                                    ),
                                                },
                                            ),
                                            op: Add,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 762..767,
                                                    value: Complex {
                                                        real: 0.0,
                                                        imag: 1.75,
                                                    },
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 777..782,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 777..778,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 781..782,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 805..841,
                    subject: Name(
                        ExprName {
                            range: 811..812,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 818..841,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 823..826,
                                    value: UnaryOp(
                                        ExprUnaryOp {
                                            range: 823..826,
                                            op: USub,
                                            operand: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 824..826,
                                                    value: Complex {
                                                        real: 0.0,
                                                        imag: 0.0,
                                                    },
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 836..841,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 836..837,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 840..841,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 864..913,
                    subject: NumberLiteral(
                        ExprNumberLiteral {
                            range: 870..871,
                            value: Int(
                                4,
                            ),
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 877..913,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 882..895,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 882..883,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 882..883,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 886..887,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 886..887,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 890..891,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 890..891,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 894..895,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 894..895,
                                                        value: Int(
                                                            3,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 905..913,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 905..906,
                                                    id: "x",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: BooleanLiteral(
                                            ExprBooleanLiteral {
                                                range: 909..913,
                                                value: true,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 936..975,
                    subject: Name(
                        ExprName {
                            range: 942..943,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 949..975,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 954..955,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 954..955,
                                            value: Int(
                                                0,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: Some(
                                Name(
                                    ExprName {
                                        range: 959..960,
                                        id: "x",
                                        ctx: Load,
                                    },
                                ),
                            ),
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 970..975,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 970..971,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 974..975,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 998..1098,
                    subject: Name(
                        ExprName {
                            range: 1004..1005,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1011..1037,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 1016..1022,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1017..1018,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1020..1021,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1020..1021,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1032..1037,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1032..1033,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1036..1037,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 1042..1068,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 1047..1053,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1048..1049,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1051..1052,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1051..1052,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1063..1068,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1063..1064,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1067..1068,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 1073..1098,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 1078..1083,
                                    keys: [],
                                    patterns: [],
                                    rest: Some(
                                        Identifier {
                                            id: "z",
                                            range: 1081..1082,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1093..1098,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1093..1094,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1097..1098,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1121..1162,
                    subject: Call(
                        ExprCall {
                            range: 1127..1132,
                            func: Name(
                                ExprName {
                                    range: 1127..1130,
                                    id: "Seq",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 1130..1132,
                                args: [],
                                keywords: [],
                            },
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1138..1162,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 1143..1147,
                                    patterns: [
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 1144..1146,
                                                name: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1157..1162,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1157..1158,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1161..1162,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1185..1245,
                    subject: Name(
                        ExprName {
                            range: 1191..1192,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1198..1219,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 1203..1204,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 1203..1204,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1214..1219,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1214..1215,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1218..1219,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 1224..1245,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 1229..1230,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 1229..1230,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1240..1245,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1240..1241,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1244..1245,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1268..1315,
                    subject: Name(
                        ExprName {
                            range: 1274..1275,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1281..1315,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 1286..1298,
                                    keys: [
                                        StringLiteral(
                                            ExprStringLiteral {
                                                range: 1287..1292,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 1287..1292,
                                                            value: "foo",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 1294..1297,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "bar",
                                                        range: 1294..1297,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1308..1315,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1308..1309,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: Name(
                                            ExprName {
                                                range: 1312..1315,
                                                id: "bar",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1338..1392,
                    subject: Tuple(
                        ExprTuple {
                            range: 1344..1353,
                            elts: [
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 1345..1346,
                                        value: Int(
                                            0,
                                        ),
                                    },
                                ),
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 1348..1349,
                                        value: Int(
                                            1,
                                        ),
                                    },
                                ),
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 1351..1352,
                                        value: Int(
                                            2,
                                        ),
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1359..1392,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 1364..1377,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1365..1366,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1365..1366,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1368..1369,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1368..1369,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 1371..1373,
                                                name: Some(
                                                    Identifier {
                                                        id: "x",
                                                        range: 1372..1373,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1375..1376,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1375..1376,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1387..1392,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1387..1388,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1391..1392,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1415..1529,
                    subject: Name(
                        ExprName {
                            range: 1421..1422,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1428..1451,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 1433..1436,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1434..1435,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1434..1435,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1446..1451,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1446..1447,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1450..1451,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 1456..1498,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 1461..1467,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1462..1463,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1462..1463,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1465..1466,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1465..1466,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: Some(
                                Named(
                                    ExprNamed {
                                        range: 1472..1482,
                                        target: Name(
                                            ExprName {
                                                range: 1472..1473,
                                                id: "x",
                                                ctx: Store,
                                            },
                                        ),
                                        value: Subscript(
                                            ExprSubscript {
                                                range: 1477..1482,
                                                value: Name(
                                                    ExprName {
                                                        range: 1477..1478,
                                                        id: "x",
                                                        ctx: Load,
                                                    },
                                                ),
                                                slice: Slice(
                                                    ExprSlice {
                                                        range: 1479..1481,
                                                        lower: None,
                                                        upper: Some(
                                                            NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 1480..1481,
                                                                    value: Int(
                                                                        0,
                                                                    ),
                                                                },
                                                            ),
                                                        ),
                                                        step: None,
                                                    },
                                                ),
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                            ),
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1493..1498,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1493..1494,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1497..1498,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 1503..1529,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 1508..1514,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1509..1510,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1509..1510,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 1512..1513,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 1512..1513,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1524..1529,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1524..1525,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1528..1529,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1552..1595,
                    subject: Name(
                        ExprName {
                            range: 1558..1559,
                            id: "w",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1565..1595,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 1570..1580,
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 1571..1572,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "x",
                                                        range: 1571..1572,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 1574..1575,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "y",
                                                        range: 1574..1575,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 1577..1579,
                                                name: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1590..1595,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1590..1591,
                                                    id: "z",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1594..1595,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1618..1664,
                    subject: Name(
                        ExprName {
                            range: 1624..1625,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1631..1664,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 1636..1649,
                                    value: BinOp(
                                        ExprBinOp {
                                            range: 1636..1649,
                                            left: UnaryOp(
                                                ExprUnaryOp {
                                                    range: 1636..1641,
                                                    op: USub,
                                                    operand: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 1637..1641,
                                                            value: Float(
                                                                0.25,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                            op: Sub,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 1644..1649,
                                                    value: Complex {
                                                        real: 0.0,
                                                        imag: 1.75,
                                                    },
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1659..1664,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1659..1660,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1663..1664,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1687..1726,
                    subject: Tuple(
                        ExprTuple {
                            range: 1693..1697,
                            elts: [
                                Name(
                                    ExprName {
                                        range: 1694..1695,
                                        id: "x",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1703..1726,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 1708..1711,
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 1709..1710,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "y",
                                                        range: 1709..1710,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1721..1726,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1721..1722,
                                                    id: "z",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1725..1726,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1749..1789,
                    subject: Name(
                        ExprName {
                            range: 1755..1756,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1762..1789,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 1767..1774,
                                    value: Attribute(
                                        ExprAttribute {
                                            range: 1767..1774,
                                            value: Attribute(
                                                ExprAttribute {
                                                    range: 1767..1772,
                                                    value: Attribute(
                                                        ExprAttribute {
                                                            range: 1767..1770,
                                                            value: Name(
                                                                ExprName {
                                                                    range: 1767..1768,
                                                                    id: "A",
                                                                    ctx: Load,
                                                                },
                                                            ),
                                                            attr: Identifier {
                                                                id: "B",
                                                                range: 1769..1770,
                                                            },
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    attr: Identifier {
                                                        id: "C",
                                                        range: 1771..1772,
                                                    },
                                                    ctx: Load,
                                                },
                                            ),
                                            attr: Identifier {
                                                id: "D",
                                                range: 1773..1774,
                                            },
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1784..1789,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1784..1785,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1788..1789,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1812..1849,
                    subject: Name(
                        ExprName {
                            range: 1818..1819,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1825..1849,
                            pattern: MatchSingleton(
                                PatternMatchSingleton {
                                    range: 1830..1834,
                                    value: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1844..1849,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1844..1845,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1848..1849,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1872..1906,
                    subject: Name(
                        ExprName {
                            range: 1878..1879,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1885..1906,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 1890..1891,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 1890..1891,
                                            value: Int(
                                                0,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1901..1906,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1901..1902,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1905..1906,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1929..1967,
                    subject: Name(
                        ExprName {
                            range: 1935..1936,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 1942..1967,
                            pattern: MatchSingleton(
                                PatternMatchSingleton {
                                    range: 1947..1952,
                                    value: False,
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 1962..1967,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 1962..1963,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 1966..1967,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 1990..2081,
                    subject: Name(
                        ExprName {
                            range: 1996..1997,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2003..2025,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2008..2010,
                                    patterns: [],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2020..2025,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2020..2021,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2024..2025,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 2030..2054,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2035..2039,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 2036..2038,
                                                value: StringLiteral(
                                                    ExprStringLiteral {
                                                        range: 2036..2038,
                                                        value: StringLiteralValue {
                                                            inner: Single(
                                                                StringLiteral {
                                                                    range: 2036..2038,
                                                                    value: "",
                                                                    flags: StringLiteralFlags {
                                                                        quote_style: Double,
                                                                        prefix: Empty,
                                                                        triple_quoted: false,
                                                                    },
                                                                },
                                                            ),
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2049..2054,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2049..2050,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2053..2054,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 2059..2081,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 2064..2066,
                                    value: StringLiteral(
                                        ExprStringLiteral {
                                            range: 2064..2066,
                                            value: StringLiteralValue {
                                                inner: Single(
                                                    StringLiteral {
                                                        range: 2064..2066,
                                                        value: "",
                                                        flags: StringLiteralFlags {
                                                            quote_style: Double,
                                                            prefix: Empty,
                                                            triple_quoted: false,
                                                        },
                                                    },
                                                ),
                                            },
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2076..2081,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2076..2077,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2080..2081,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2104..2138,
                    subject: Name(
                        ExprName {
                            range: 2110..2111,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2117..2138,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 2122..2123,
                                    pattern: None,
                                    name: Some(
                                        Identifier {
                                            id: "z",
                                            range: 2122..2123,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2133..2138,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2133..2134,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2137..2138,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2161..2207,
                    subject: Name(
                        ExprName {
                            range: 2167..2168,
                            id: "w",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2174..2207,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2179..2192,
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2180..2181,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "x",
                                                        range: 2180..2181,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2183..2184,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "y",
                                                        range: 2183..2184,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 2186..2191,
                                                name: Some(
                                                    Identifier {
                                                        id: "rest",
                                                        range: 2187..2191,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2202..2207,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2202..2203,
                                                    id: "z",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2206..2207,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2230..2307,
                    subject: Name(
                        ExprName {
                            range: 2236..2237,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2243..2307,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 2248..2278,
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2249..2255,
                                                pattern: Some(
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 2249..2250,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 2249..2250,
                                                                    value: Int(
                                                                        0,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ),
                                                name: Some(
                                                    Identifier {
                                                        id: "z",
                                                        range: 2254..2255,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2260..2266,
                                                pattern: Some(
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 2260..2261,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 2260..2261,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ),
                                                name: Some(
                                                    Identifier {
                                                        id: "z",
                                                        range: 2265..2266,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2271..2277,
                                                pattern: Some(
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 2271..2272,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 2271..2272,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ),
                                                name: Some(
                                                    Identifier {
                                                        id: "z",
                                                        range: 2276..2277,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: Some(
                                Compare(
                                    ExprCompare {
                                        range: 2282..2292,
                                        left: Name(
                                            ExprName {
                                                range: 2282..2283,
                                                id: "z",
                                                ctx: Load,
                                            },
                                        ),
                                        ops: [
                                            Eq,
                                        ],
                                        comparators: [
                                            BinOp(
                                                ExprBinOp {
                                                    range: 2287..2292,
                                                    left: Name(
                                                        ExprName {
                                                            range: 2287..2288,
                                                            id: "x",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    op: Mod,
                                                    right: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 2291..2292,
                                                            value: Int(
                                                                2,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                        ],
                                    },
                                ),
                            ),
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2302..2307,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2302..2303,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2306..2307,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2330..2499,
                    subject: Name(
                        ExprName {
                            range: 2336..2337,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2343..2378,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 2348..2363,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2349..2350,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 2352..2362,
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 2353..2354,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 2353..2354,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 2356..2357,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 2356..2357,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchMapping(
                                                        PatternMatchMapping {
                                                            range: 2359..2361,
                                                            keys: [],
                                                            patterns: [],
                                                            rest: None,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2373..2378,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2373..2374,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2377..2378,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 2383..2472,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 2388..2457,
                                    patterns: [
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 2388..2411,
                                                keys: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 2389..2390,
                                                            value: Int(
                                                                0,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchOr(
                                                        PatternMatchOr {
                                                            range: 2392..2410,
                                                            patterns: [
                                                                MatchSequence(
                                                                    PatternMatchSequence {
                                                                        range: 2392..2402,
                                                                        patterns: [
                                                                            MatchValue(
                                                                                PatternMatchValue {
                                                                                    range: 2393..2394,
                                                                                    value: NumberLiteral(
                                                                                        ExprNumberLiteral {
                                                                                            range: 2393..2394,
                                                                                            value: Int(
                                                                                                1,
                                                                                            ),
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                            MatchValue(
                                                                                PatternMatchValue {
                                                                                    range: 2396..2397,
                                                                                    value: NumberLiteral(
                                                                                        ExprNumberLiteral {
                                                                                            range: 2396..2397,
                                                                                            value: Int(
                                                                                                2,
                                                                                            ),
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                            MatchMapping(
                                                                                PatternMatchMapping {
                                                                                    range: 2399..2401,
                                                                                    keys: [],
                                                                                    patterns: [],
                                                                                    rest: None,
                                                                                },
                                                                            ),
                                                                        ],
                                                                    },
                                                                ),
                                                                MatchSingleton(
                                                                    PatternMatchSingleton {
                                                                        range: 2405..2410,
                                                                        value: False,
                                                                    },
                                                                ),
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 2414..2423,
                                                keys: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 2415..2416,
                                                            value: Int(
                                                                1,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchSequence(
                                                        PatternMatchSequence {
                                                            range: 2418..2422,
                                                            patterns: [
                                                                MatchSequence(
                                                                    PatternMatchSequence {
                                                                        range: 2419..2421,
                                                                        patterns: [],
                                                                    },
                                                                ),
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 2426..2441,
                                                keys: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 2427..2428,
                                                            value: Int(
                                                                0,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchSequence(
                                                        PatternMatchSequence {
                                                            range: 2430..2440,
                                                            patterns: [
                                                                MatchValue(
                                                                    PatternMatchValue {
                                                                        range: 2431..2432,
                                                                        value: NumberLiteral(
                                                                            ExprNumberLiteral {
                                                                                range: 2431..2432,
                                                                                value: Int(
                                                                                    1,
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                MatchValue(
                                                                    PatternMatchValue {
                                                                        range: 2434..2435,
                                                                        value: NumberLiteral(
                                                                            ExprNumberLiteral {
                                                                                range: 2434..2435,
                                                                                value: Int(
                                                                                    2,
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                                MatchMapping(
                                                                    PatternMatchMapping {
                                                                        range: 2437..2439,
                                                                        keys: [],
                                                                        patterns: [],
                                                                        rest: None,
                                                                    },
                                                                ),
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 2444..2446,
                                                patterns: [],
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 2449..2452,
                                                value: StringLiteral(
                                                    ExprStringLiteral {
                                                        range: 2449..2452,
                                                        value: StringLiteralValue {
                                                            inner: Single(
                                                                StringLiteral {
                                                                    range: 2449..2452,
                                                                    value: "X",
                                                                    flags: StringLiteralFlags {
                                                                        quote_style: Double,
                                                                        prefix: Empty,
                                                                        triple_quoted: false,
                                                                    },
                                                                },
                                                            ),
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchMapping(
                                            PatternMatchMapping {
                                                range: 2455..2457,
                                                keys: [],
                                                patterns: [],
                                                rest: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2467..2472,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2467..2468,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2471..2472,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 2477..2499,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2482..2484,
                                    patterns: [],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2494..2499,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2494..2495,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2498..2499,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2522..2568,
                    subject: Tuple(
                        ExprTuple {
                            range: 2528..2537,
                            elts: [
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 2529..2530,
                                        value: Int(
                                            0,
                                        ),
                                    },
                                ),
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 2532..2533,
                                        value: Int(
                                            1,
                                        ),
                                    },
                                ),
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 2535..2536,
                                        value: Int(
                                            2,
                                        ),
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2543..2568,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2548..2553,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 2548..2549,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 2548..2549,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 2551..2553,
                                                name: Some(
                                                    Identifier {
                                                        id: "x",
                                                        range: 2552..2553,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2563..2568,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2563..2564,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2567..2568,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2591..2638,
                    subject: Tuple(
                        ExprTuple {
                            range: 2597..2606,
                            elts: [
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 2598..2599,
                                        value: Int(
                                            0,
                                        ),
                                    },
                                ),
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 2601..2602,
                                        value: Int(
                                            1,
                                        ),
                                    },
                                ),
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 2604..2605,
                                        value: Int(
                                            2,
                                        ),
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: true,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2612..2638,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2617..2623,
                                    patterns: [
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 2617..2619,
                                                name: Some(
                                                    Identifier {
                                                        id: "x",
                                                        range: 2618..2619,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 2621..2622,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 2621..2622,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2633..2638,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2633..2634,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2637..2638,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2661..2697,
                    subject: Tuple(
                        ExprTuple {
                            range: 2667..2669,
                            elts: [
                                Name(
                                    ExprName {
                                        range: 2667..2668,
                                        id: "x",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2675..2697,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2680..2682,
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2680..2681,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "y",
                                                        range: 2680..2681,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2692..2697,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2692..2693,
                                                    id: "z",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2696..2697,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2720..2760,
                    subject: Tuple(
                        ExprTuple {
                            range: 2726..2730,
                            elts: [
                                Name(
                                    ExprName {
                                        range: 2726..2727,
                                        id: "w",
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        range: 2729..2730,
                                        id: "x",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2736..2760,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2741..2745,
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2741..2742,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "y",
                                                        range: 2741..2742,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2744..2745,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "z",
                                                        range: 2744..2745,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2755..2760,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2755..2756,
                                                    id: "v",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2759..2760,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2783..2829,
                    subject: Tuple(
                        ExprTuple {
                            range: 2789..2796,
                            elts: [
                                Named(
                                    ExprNamed {
                                        range: 2789..2795,
                                        target: Name(
                                            ExprName {
                                                range: 2789..2790,
                                                id: "w",
                                                ctx: Store,
                                            },
                                        ),
                                        value: Name(
                                            ExprName {
                                                range: 2794..2795,
                                                id: "x",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2802..2829,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 2807..2814,
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 2807..2813,
                                                pattern: Some(
                                                    MatchAs(
                                                        PatternMatchAs {
                                                            range: 2807..2808,
                                                            pattern: None,
                                                            name: Some(
                                                                Identifier {
                                                                    id: "y",
                                                                    range: 2807..2808,
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ),
                                                name: Some(
                                                    Identifier {
                                                        id: "v",
                                                        range: 2812..2813,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 2824..2829,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 2824..2825,
                                                    id: "z",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 2828..2829,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2831..2952,
                    subject: Name(
                        ExprName {
                            range: 2837..2838,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2927..2952,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 2932..2938,
                                    value: FString(
                                        ExprFString {
                                            range: 2932..2938,
                                            value: FStringValue {
                                                inner: Single(
                                                    FString(
                                                        FString {
                                                            range: 2932..2938,
                                                            elements: [
                                                                Expression(
                                                                    FStringExpressionElement {
                                                                        range: 2934..2937,
                                                                        expression: Name(
                                                                            ExprName {
                                                                                range: 2935..2936,
                                                                                id: "y",
                                                                                ctx: Load,
                                                                            },
                                                                        ),
                                                                        debug_text: None,
                                                                        conversion: None,
                                                                        format_spec: None,
                                                                    },
                                                                ),
                                                            ],
                                                            flags: FStringFlags {
                                                                quote_style: Double,
                                                                prefix: Regular,
                                                                triple_quoted: false,
                                                            },
                                                        },
                                                    ),
                                                ),
                                            },
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Pass(
                                    StmtPass {
                                        range: 2948..2952,
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 2953..3025,
                    subject: Dict(
                        ExprDict {
                            range: 2959..2970,
                            keys: [
                                Some(
                                    StringLiteral(
                                        ExprStringLiteral {
                                            range: 2960..2966,
                                            value: StringLiteralValue {
                                                inner: Single(
                                                    StringLiteral {
                                                        range: 2960..2966,
                                                        value: "test",
                                                        flags: StringLiteralFlags {
                                                            quote_style: Double,
                                                            prefix: Empty,
                                                            triple_quoted: false,
                                                        },
                                                    },
                                                ),
                                            },
                                        },
                                    ),
                                ),
                            ],
                            values: [
                                NumberLiteral(
                                    ExprNumberLiteral {
                                        range: 2968..2969,
                                        value: Int(
                                            1,
                                        ),
                                    },
                                ),
                            ],
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 2976..3025,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 2981..3004,
                                    keys: [],
                                    patterns: [],
                                    rest: Some(
                                        Identifier {
                                            id: "rest",
                                            range: 2993..2997,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3014..3025,
                                        value: Call(
                                            ExprCall {
                                                range: 3014..3025,
                                                func: Name(
                                                    ExprName {
                                                        range: 3014..3019,
                                                        id: "print",
                                                        ctx: Load,
                                                    },
                                                ),
                                                arguments: Arguments {
                                                    range: 3019..3025,
                                                    args: [
                                                        Name(
                                                            ExprName {
                                                                range: 3020..3024,
                                                                id: "rest",
                                                                ctx: Load,
                                                            },
                                                        ),
                                                    ],
                                                    keywords: [],
                                                },
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3026..3129,
                    subject: Dict(
                        ExprDict {
                            range: 3032..3049,
                            keys: [
                                Some(
                                    StringLiteral(
                                        ExprStringLiteral {
                                            range: 3033..3040,
                                            value: StringLiteralValue {
                                                inner: Single(
                                                    StringLiteral {
                                                        range: 3033..3040,
                                                        value: "label",
                                                        flags: StringLiteralFlags {
                                                            quote_style: Double,
                                                            prefix: Empty,
                                                            triple_quoted: false,
                                                        },
                                                    },
                                                ),
                                            },
                                        },
                                    ),
                                ),
                            ],
                            values: [
                                StringLiteral(
                                    ExprStringLiteral {
                                        range: 3042..3048,
                                        value: StringLiteralValue {
                                            inner: Single(
                                                StringLiteral {
                                                    range: 3042..3048,
                                                    value: "test",
                                                    flags: StringLiteralFlags {
                                                        quote_style: Double,
                                                        prefix: Empty,
                                                        triple_quoted: false,
                                                    },
                                                },
                                            ),
                                        },
                                    },
                                ),
                            ],
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3055..3129,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 3060..3107,
                                    keys: [
                                        StringLiteral(
                                            ExprStringLiteral {
                                                range: 3070..3077,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 3070..3077,
                                                            value: "label",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 3079..3100,
                                                pattern: Some(
                                                    MatchOr(
                                                        PatternMatchOr {
                                                            range: 3079..3091,
                                                            patterns: [
                                                                MatchClass(
                                                                    PatternMatchClass {
                                                                        range: 3079..3084,
                                                                        cls: Name(
                                                                            ExprName {
                                                                                range: 3079..3082,
                                                                                id: "str",
                                                                                ctx: Load,
                                                                            },
                                                                        ),
                                                                        arguments: PatternArguments {
                                                                            range: 3082..3084,
                                                                            patterns: [],
                                                                            keywords: [],
                                                                        },
                                                                    },
                                                                ),
                                                                MatchSingleton(
                                                                    PatternMatchSingleton {
                                                                        range: 3087..3091,
                                                                        value: None,
                                                                    },
                                                                ),
                                                            ],
                                                        },
                                                    ),
                                                ),
                                                name: Some(
                                                    Identifier {
                                                        id: "label",
                                                        range: 3095..3100,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3117..3129,
                                        value: Call(
                                            ExprCall {
                                                range: 3117..3129,
                                                func: Name(
                                                    ExprName {
                                                        range: 3117..3122,
                                                        id: "print",
                                                        ctx: Load,
                                                    },
                                                ),
                                                arguments: Arguments {
                                                    range: 3122..3129,
                                                    args: [
                                                        Name(
                                                            ExprName {
                                                                range: 3123..3128,
                                                                id: "label",
                                                                ctx: Load,
                                                            },
                                                        ),
                                                    ],
                                                    keywords: [],
                                                },
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3130..3170,
                    subject: Name(
                        ExprName {
                            range: 3136..3137,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3143..3170,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 3148..3155,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3149..3150,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3149..3150,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3152..3153,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3152..3153,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 3165..3170,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 3165..3166,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 3169..3170,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3171..3211,
                    subject: Name(
                        ExprName {
                            range: 3177..3178,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3184..3211,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 3189..3196,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3190..3191,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3190..3191,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3193..3194,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3193..3194,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 3206..3211,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 3206..3207,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 3210..3211,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3212..3249,
                    subject: Name(
                        ExprName {
                            range: 3218..3219,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3225..3249,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 3230..3234,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3231..3232,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3231..3232,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Assign(
                                    StmtAssign {
                                        range: 3244..3249,
                                        targets: [
                                            Name(
                                                ExprName {
                                                    range: 3244..3245,
                                                    id: "y",
                                                    ctx: Store,
                                                },
                                            ),
                                        ],
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 3248..3249,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3250..3284,
                    subject: Tuple(
                        ExprTuple {
                            range: 3256..3258,
                            elts: [
                                Name(
                                    ExprName {
                                        range: 3256..3257,
                                        id: "x",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3264..3284,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 3269..3270,
                                    pattern: None,
                                    name: Some(
                                        Identifier {
                                            id: "z",
                                            range: 3269..3270,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Pass(
                                    StmtPass {
                                        range: 3280..3284,
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3285..3321,
                    subject: Tuple(
                        ExprTuple {
                            range: 3291..3295,
                            elts: [
                                Name(
                                    ExprName {
                                        range: 3291..3292,
                                        id: "x",
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        range: 3294..3295,
                                        id: "y",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3301..3321,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 3306..3307,
                                    pattern: None,
                                    name: Some(
                                        Identifier {
                                            id: "z",
                                            range: 3306..3307,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Pass(
                                    StmtPass {
                                        range: 3317..3321,
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3322..3359,
                    subject: Tuple(
                        ExprTuple {
                            range: 3328..3333,
                            elts: [
                                Name(
                                    ExprName {
                                        range: 3328..3329,
                                        id: "x",
                                        ctx: Load,
                                    },
                                ),
                                Name(
                                    ExprName {
                                        range: 3331..3332,
                                        id: "y",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3339..3359,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 3344..3345,
                                    pattern: None,
                                    name: Some(
                                        Identifier {
                                            id: "z",
                                            range: 3344..3345,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Pass(
                                    StmtPass {
                                        range: 3355..3359,
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3385..3475,
                    subject: Name(
                        ExprName {
                            range: 3391..3392,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3398..3420,
                            pattern: MatchSingleton(
                                PatternMatchSingleton {
                                    range: 3403..3407,
                                    value: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3417..3420,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3417..3420,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3425..3447,
                            pattern: MatchSingleton(
                                PatternMatchSingleton {
                                    range: 3430..3434,
                                    value: True,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3444..3447,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3444..3447,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3452..3475,
                            pattern: MatchSingleton(
                                PatternMatchSingleton {
                                    range: 3457..3462,
                                    value: False,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3472..3475,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3472..3475,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3497..3821,
                    subject: Name(
                        ExprName {
                            range: 3503..3504,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3510..3531,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3515..3518,
                                    value: Attribute(
                                        ExprAttribute {
                                            range: 3515..3518,
                                            value: Name(
                                                ExprName {
                                                    range: 3515..3516,
                                                    id: "a",
                                                    ctx: Load,
                                                },
                                            ),
                                            attr: Identifier {
                                                id: "b",
                                                range: 3517..3518,
                                            },
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3528..3531,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3528..3531,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3536..3559,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3541..3546,
                                    value: Attribute(
                                        ExprAttribute {
                                            range: 3541..3546,
                                            value: Attribute(
                                                ExprAttribute {
                                                    range: 3541..3544,
                                                    value: Name(
                                                        ExprName {
                                                            range: 3541..3542,
                                                            id: "a",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    attr: Identifier {
                                                        id: "b",
                                                        range: 3543..3544,
                                                    },
                                                    ctx: Load,
                                                },
                                            ),
                                            attr: Identifier {
                                                id: "c",
                                                range: 3545..3546,
                                            },
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3556..3559,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3556..3559,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3564..3584,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3569..3571,
                                    value: StringLiteral(
                                        ExprStringLiteral {
                                            range: 3569..3571,
                                            value: StringLiteralValue {
                                                inner: Single(
                                                    StringLiteral {
                                                        range: 3569..3571,
                                                        value: "",
                                                        flags: StringLiteralFlags {
                                                            quote_style: Single,
                                                            prefix: Empty,
                                                            triple_quoted: false,
                                                        },
                                                    },
                                                ),
                                            },
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3581..3584,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3581..3584,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3589..3610,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3594..3597,
                                    value: BytesLiteral(
                                        ExprBytesLiteral {
                                            range: 3594..3597,
                                            value: BytesLiteralValue {
                                                inner: Single(
                                                    BytesLiteral {
                                                        range: 3594..3597,
                                                        value: [],
                                                        flags: BytesLiteralFlags {
                                                            quote_style: Single,
                                                            prefix: Regular,
                                                            triple_quoted: false,
                                                        },
                                                    },
                                                ),
                                            },
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3607..3610,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3607..3610,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3615..3634,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3620..3621,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 3620..3621,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3631..3634,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3631..3634,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3639..3660,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3644..3647,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 3644..3647,
                                            value: Float(
                                                1.0,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3657..3660,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3657..3660,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3665..3687,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3670..3674,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 3670..3674,
                                            value: Complex {
                                                real: 0.0,
                                                imag: 1.0,
                                            },
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3684..3687,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3684..3687,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3692..3716,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3697..3703,
                                    value: BinOp(
                                        ExprBinOp {
                                            range: 3697..3703,
                                            left: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 3697..3698,
                                                    value: Int(
                                                        1,
                                                    ),
                                                },
                                            ),
                                            op: Add,
                                            right: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 3701..3703,
                                                    value: Complex {
                                                        real: 0.0,
                                                        imag: 1.0,
                                                    },
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3713..3716,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3713..3716,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3721..3741,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3726..3728,
                                    value: UnaryOp(
                                        ExprUnaryOp {
                                            range: 3726..3728,
                                            op: USub,
                                            operand: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 3727..3728,
                                                    value: Int(
                                                        1,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3738..3741,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3738..3741,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3746..3767,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3751..3754,
                                    value: UnaryOp(
                                        ExprUnaryOp {
                                            range: 3751..3754,
                                            op: USub,
                                            operand: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 3752..3754,
                                                    value: Float(
                                                        1.0,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3764..3767,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3764..3767,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3772..3795,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3777..3782,
                                    value: UnaryOp(
                                        ExprUnaryOp {
                                            range: 3777..3782,
                                            op: USub,
                                            operand: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 3778..3782,
                                                    value: Int(
                                                        1,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3792..3795,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3792..3795,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3800..3821,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 3806..3807,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 3806..3807,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3818..3821,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3818..3821,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3840..3927,
                    subject: Name(
                        ExprName {
                            range: 3846..3847,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3853..3876,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 3858..3863,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3858..3859,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3858..3859,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3862..3863,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3862..3863,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3873..3876,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3873..3876,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3881..3927,
                            pattern: MatchOr(
                                PatternMatchOr {
                                    range: 3886..3914,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3886..3888,
                                                value: StringLiteral(
                                                    ExprStringLiteral {
                                                        range: 3886..3888,
                                                        value: StringLiteralValue {
                                                            inner: Single(
                                                                StringLiteral {
                                                                    range: 3886..3888,
                                                                    value: "",
                                                                    flags: StringLiteralFlags {
                                                                        quote_style: Single,
                                                                        prefix: Empty,
                                                                        triple_quoted: false,
                                                                    },
                                                                },
                                                            ),
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3891..3894,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 3891..3894,
                                                        value: Float(
                                                            1.1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3897..3899,
                                                value: UnaryOp(
                                                    ExprUnaryOp {
                                                        range: 3897..3899,
                                                        op: USub,
                                                        operand: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 3898..3899,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3902..3908,
                                                value: BinOp(
                                                    ExprBinOp {
                                                        range: 3902..3908,
                                                        left: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 3902..3903,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                        op: Add,
                                                        right: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 3906..3908,
                                                                value: Complex {
                                                                    real: 0.0,
                                                                    imag: 1.0,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 3911..3914,
                                                value: Attribute(
                                                    ExprAttribute {
                                                        range: 3911..3914,
                                                        value: Name(
                                                            ExprName {
                                                                range: 3911..3912,
                                                                id: "a",
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        attr: Identifier {
                                                            id: "b",
                                                            range: 3913..3914,
                                                        },
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3924..3927,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3924..3927,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 3946..4163,
                    subject: Name(
                        ExprName {
                            range: 3952..3953,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 3959..3978,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 3964..3965,
                                    pattern: None,
                                    name: Some(
                                        Identifier {
                                            id: "a",
                                            range: 3964..3965,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 3975..3978,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 3975..3978,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 3983..4007,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 3988..3994,
                                    pattern: Some(
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 3988..3989,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "a",
                                                        range: 3988..3989,
                                                    },
                                                ),
                                            },
                                        ),
                                    ),
                                    name: Some(
                                        Identifier {
                                            id: "b",
                                            range: 3993..3994,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4004..4007,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4004..4007,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4012..4042,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 4017..4029,
                                    pattern: Some(
                                        MatchOr(
                                            PatternMatchOr {
                                                range: 4017..4022,
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 4017..4018,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 4017..4018,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 4021..4022,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 4021..4022,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ),
                                    name: Some(
                                        Identifier {
                                            id: "two",
                                            range: 4026..4029,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4039..4042,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4039..4042,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4047..4078,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 4052..4065,
                                    pattern: Some(
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4052..4058,
                                                value: BinOp(
                                                    ExprBinOp {
                                                        range: 4052..4058,
                                                        left: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4052..4053,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                        op: Add,
                                                        right: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4056..4058,
                                                                value: Complex {
                                                                    real: 0.0,
                                                                    imag: 3.0,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ),
                                    name: Some(
                                        Identifier {
                                            id: "sum",
                                            range: 4062..4065,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4075..4078,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4075..4078,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4083..4110,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 4088..4097,
                                    pattern: Some(
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4088..4091,
                                                value: Attribute(
                                                    ExprAttribute {
                                                        range: 4088..4091,
                                                        value: Name(
                                                            ExprName {
                                                                range: 4088..4089,
                                                                id: "a",
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        attr: Identifier {
                                                            id: "b",
                                                            range: 4090..4091,
                                                        },
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    ),
                                    name: Some(
                                        Identifier {
                                            id: "ab",
                                            range: 4095..4097,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4107..4110,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4107..4110,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4115..4134,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 4120..4121,
                                    pattern: None,
                                    name: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4131..4134,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4131..4134,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4139..4163,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 4144..4150,
                                    pattern: Some(
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 4144..4145,
                                                pattern: None,
                                                name: None,
                                            },
                                        ),
                                    ),
                                    name: Some(
                                        Identifier {
                                            id: "x",
                                            range: 4149..4150,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4160..4163,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4160..4163,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 4188..4439,
                    subject: Name(
                        ExprName {
                            range: 4194..4195,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 4201..4226,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4206..4213,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4206..4207,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4206..4207,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4209..4210,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4209..4210,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4212..4213,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4212..4213,
                                                        value: Int(
                                                            3,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4223..4226,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4223..4226,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4231..4259,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4236..4246,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4237..4238,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4237..4238,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4240..4241,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4240..4241,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4243..4244,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4243..4244,
                                                        value: Int(
                                                            3,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4256..4259,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4256..4259,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4264..4304,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4269..4291,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4270..4276,
                                                value: BinOp(
                                                    ExprBinOp {
                                                        range: 4270..4276,
                                                        left: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4270..4271,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                        op: Add,
                                                        right: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4274..4276,
                                                                value: Complex {
                                                                    real: 0.0,
                                                                    imag: 2.0,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 4278..4279,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "a",
                                                        range: 4278..4279,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchSingleton(
                                            PatternMatchSingleton {
                                                range: 4281..4285,
                                                value: None,
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4287..4290,
                                                value: Attribute(
                                                    ExprAttribute {
                                                        range: 4287..4290,
                                                        value: Name(
                                                            ExprName {
                                                                range: 4287..4288,
                                                                id: "a",
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        attr: Identifier {
                                                            id: "b",
                                                            range: 4289..4290,
                                                        },
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4301..4304,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4301..4304,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4309..4343,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 4314..4330,
                                    pattern: Some(
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 4314..4325,
                                                patterns: [
                                                    MatchAs(
                                                        PatternMatchAs {
                                                            range: 4315..4321,
                                                            pattern: Some(
                                                                MatchValue(
                                                                    PatternMatchValue {
                                                                        range: 4315..4316,
                                                                        value: NumberLiteral(
                                                                            ExprNumberLiteral {
                                                                                range: 4315..4316,
                                                                                value: Int(
                                                                                    1,
                                                                                ),
                                                                            },
                                                                        ),
                                                                    },
                                                                ),
                                                            ),
                                                            name: Some(
                                                                Identifier {
                                                                    id: "X",
                                                                    range: 4320..4321,
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchAs(
                                                        PatternMatchAs {
                                                            range: 4323..4324,
                                                            pattern: None,
                                                            name: Some(
                                                                Identifier {
                                                                    id: "b",
                                                                    range: 4323..4324,
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ),
                                    name: Some(
                                        Identifier {
                                            id: "S",
                                            range: 4329..4330,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4340..4343,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4340..4343,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4348..4380,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4353..4367,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4354..4355,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4354..4355,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4357..4358,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4357..4358,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4360..4366,
                                                value: BinOp(
                                                    ExprBinOp {
                                                        range: 4360..4366,
                                                        left: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4360..4361,
                                                                value: Int(
                                                                    3,
                                                                ),
                                                            },
                                                        ),
                                                        op: Add,
                                                        right: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4364..4366,
                                                                value: Complex {
                                                                    real: 0.0,
                                                                    imag: 1.0,
                                                                },
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4377..4380,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4377..4380,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4385..4413,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4390..4400,
                                    patterns: [
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 4391..4396,
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 4392..4393,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 4392..4393,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 4394..4395,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 4394..4395,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4398..4399,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4398..4399,
                                                        value: Int(
                                                            3,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4410..4413,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4410..4413,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4418..4439,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4423..4426,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4424..4425,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4424..4425,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4436..4439,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4436..4439,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 4460..4589,
                    subject: Name(
                        ExprName {
                            range: 4466..4467,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 4473..4494,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4478..4481,
                                    patterns: [
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 4478..4480,
                                                name: Some(
                                                    Identifier {
                                                        id: "a",
                                                        range: 4479..4480,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4491..4494,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4491..4494,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4499..4520,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4504..4507,
                                    patterns: [
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 4504..4506,
                                                name: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4517..4520,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4517..4520,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4525..4556,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4530..4543,
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4531..4532,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4531..4532,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4534..4535,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4534..4535,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 4537..4542,
                                                name: Some(
                                                    Identifier {
                                                        id: "rest",
                                                        range: 4538..4542,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4553..4556,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4553..4556,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4561..4589,
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    range: 4566..4576,
                                    patterns: [
                                        MatchStar(
                                            PatternMatchStar {
                                                range: 4567..4569,
                                                name: None,
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4571..4572,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4571..4572,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                range: 4574..4575,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 4574..4575,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4586..4589,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4586..4589,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 4611..4883,
                    subject: Name(
                        ExprName {
                            range: 4617..4618,
                            id: "x",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 4624..4649,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 4629..4636,
                                    cls: Name(
                                        ExprName {
                                            range: 4629..4634,
                                            id: "Point",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 4634..4636,
                                        patterns: [],
                                        keywords: [],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4646..4649,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4646..4649,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4654..4683,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 4659..4670,
                                    cls: Attribute(
                                        ExprAttribute {
                                            range: 4659..4668,
                                            value: Attribute(
                                                ExprAttribute {
                                                    range: 4659..4662,
                                                    value: Name(
                                                        ExprName {
                                                            range: 4659..4660,
                                                            id: "a",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    attr: Identifier {
                                                        id: "b",
                                                        range: 4661..4662,
                                                    },
                                                    ctx: Load,
                                                },
                                            ),
                                            attr: Identifier {
                                                id: "Point",
                                                range: 4663..4668,
                                            },
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 4668..4670,
                                        patterns: [],
                                        keywords: [],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4680..4683,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4680..4683,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4688..4718,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 4693..4705,
                                    cls: Name(
                                        ExprName {
                                            range: 4693..4700,
                                            id: "Point2D",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 4700..4705,
                                        patterns: [],
                                        keywords: [
                                            PatternKeyword {
                                                range: 4701..4704,
                                                attr: Identifier {
                                                    id: "x",
                                                    range: 4701..4702,
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        range: 4703..4704,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4703..4704,
                                                                value: Int(
                                                                    0,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4715..4718,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4715..4718,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4723..4759,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 4728..4746,
                                    cls: Name(
                                        ExprName {
                                            range: 4728..4735,
                                            id: "Point2D",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 4735..4746,
                                        patterns: [],
                                        keywords: [
                                            PatternKeyword {
                                                range: 4736..4739,
                                                attr: Identifier {
                                                    id: "x",
                                                    range: 4736..4737,
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        range: 4738..4739,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4738..4739,
                                                                value: Int(
                                                                    0,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                            PatternKeyword {
                                                range: 4741..4744,
                                                attr: Identifier {
                                                    id: "y",
                                                    range: 4741..4742,
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        range: 4743..4744,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4743..4744,
                                                                value: Int(
                                                                    0,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4756..4759,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4756..4759,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4764..4795,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 4769..4782,
                                    cls: Name(
                                        ExprName {
                                            range: 4769..4776,
                                            id: "Point2D",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 4776..4782,
                                        patterns: [
                                            MatchValue(
                                                PatternMatchValue {
                                                    range: 4777..4778,
                                                    value: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 4777..4778,
                                                            value: Int(
                                                                0,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                            MatchValue(
                                                PatternMatchValue {
                                                    range: 4780..4781,
                                                    value: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 4780..4781,
                                                            value: Int(
                                                                1,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                        ],
                                        keywords: [],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4792..4795,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4792..4795,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4800..4838,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 4805..4825,
                                    cls: Name(
                                        ExprName {
                                            range: 4805..4812,
                                            id: "Point2D",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 4812..4825,
                                        patterns: [
                                            MatchSequence(
                                                PatternMatchSequence {
                                                    range: 4813..4819,
                                                    patterns: [
                                                        MatchValue(
                                                            PatternMatchValue {
                                                                range: 4814..4815,
                                                                value: NumberLiteral(
                                                                    ExprNumberLiteral {
                                                                        range: 4814..4815,
                                                                        value: Int(
                                                                            0,
                                                                        ),
                                                                    },
                                                                ),
                                                            },
                                                        ),
                                                        MatchValue(
                                                            PatternMatchValue {
                                                                range: 4817..4818,
                                                                value: NumberLiteral(
                                                                    ExprNumberLiteral {
                                                                        range: 4817..4818,
                                                                        value: Int(
                                                                            1,
                                                                        ),
                                                                    },
                                                                ),
                                                            },
                                                        ),
                                                    ],
                                                },
                                            ),
                                        ],
                                        keywords: [
                                            PatternKeyword {
                                                range: 4821..4824,
                                                attr: Identifier {
                                                    id: "y",
                                                    range: 4821..4822,
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        range: 4823..4824,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4823..4824,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4835..4838,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4835..4838,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4843..4883,
                            pattern: MatchClass(
                                PatternMatchClass {
                                    range: 4848..4870,
                                    cls: Name(
                                        ExprName {
                                            range: 4848..4855,
                                            id: "Point2D",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 4855..4870,
                                        patterns: [],
                                        keywords: [
                                            PatternKeyword {
                                                range: 4856..4864,
                                                attr: Identifier {
                                                    id: "x",
                                                    range: 4856..4857,
                                                },
                                                pattern: MatchSequence(
                                                    PatternMatchSequence {
                                                        range: 4858..4864,
                                                        patterns: [
                                                            MatchValue(
                                                                PatternMatchValue {
                                                                    range: 4859..4860,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            range: 4859..4860,
                                                                            value: Int(
                                                                                0,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                            MatchValue(
                                                                PatternMatchValue {
                                                                    range: 4862..4863,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            range: 4862..4863,
                                                                            value: Int(
                                                                                1,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        ],
                                                    },
                                                ),
                                            },
                                            PatternKeyword {
                                                range: 4866..4869,
                                                attr: Identifier {
                                                    id: "y",
                                                    range: 4866..4867,
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        range: 4868..4869,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                range: 4868..4869,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                        ],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4880..4883,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4880..4883,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 4907..5001,
                    subject: Named(
                        ExprNamed {
                            range: 4913..4919,
                            target: Name(
                                ExprName {
                                    range: 4913..4914,
                                    id: "x",
                                    ctx: Store,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    range: 4918..4919,
                                    id: "b",
                                    ctx: Load,
                                },
                            ),
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 4925..4949,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 4930..4936,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 4931..4932,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 4934..4935,
                                                pattern: None,
                                                name: None,
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4946..4949,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4946..4949,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 4954..5001,
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    range: 4959..4988,
                                    keys: [
                                        StringLiteral(
                                            ExprStringLiteral {
                                                range: 4960..4962,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 4960..4962,
                                                            value: "",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Single,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        NoneLiteral(
                                            ExprNoneLiteral {
                                                range: 4967..4971,
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchAs(
                                            PatternMatchAs {
                                                range: 4964..4965,
                                                pattern: None,
                                                name: Some(
                                                    Identifier {
                                                        id: "a",
                                                        range: 4964..4965,
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchSequence(
                                            PatternMatchSequence {
                                                range: 4973..4979,
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 4974..4975,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 4974..4975,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            range: 4977..4978,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    range: 4977..4978,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                    rest: Some(
                                        Identifier {
                                            id: "rest",
                                            range: 4983..4987,
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 4998..5001,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 4998..5001,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Match(
                StmtMatch {
                    range: 5019..5079,
                    subject: Name(
                        ExprName {
                            range: 5025..5026,
                            id: "y",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 5032..5053,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 5037..5038,
                                    pattern: None,
                                    name: Some(
                                        Identifier {
                                            id: "a",
                                            range: 5037..5038,
                                        },
                                    ),
                                },
                            ),
                            guard: Some(
                                Named(
                                    ExprNamed {
                                        range: 5042..5048,
                                        target: Name(
                                            ExprName {
                                                range: 5042..5043,
                                                id: "b",
                                                ctx: Store,
                                            },
                                        ),
                                        value: Name(
                                            ExprName {
                                                range: 5047..5048,
                                                id: "c",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                            ),
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 5050..5053,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 5050..5053,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 5058..5079,
                            pattern: MatchAs(
                                PatternMatchAs {
                                    range: 5063..5064,
                                    pattern: None,
                                    name: Some(
                                        Identifier {
                                            id: "e",
                                            range: 5063..5064,
                                        },
                                    ),
                                },
                            ),
                            guard: Some(
                                Compare(
                                    ExprCompare {
                                        range: 5069..5074,
                                        left: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 5069..5070,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                        ops: [
                                            Lt,
                                        ],
                                        comparators: [
                                            NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 5073..5074,
                                                    value: Int(
                                                        2,
                                                    ),
                                                },
                                            ),
                                        ],
                                    },
                                ),
                            ),
                            body: [
                                Expr(
                                    StmtExpr {
                                        range: 5076..5079,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                range: 5076..5079,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Expr(
                StmtExpr {
                    range: 5108..5123,
                    value: Tuple(
                        ExprTuple {
                            range: 5108..5123,
                            elts: [
                                BinOp(
                                    ExprBinOp {
                                        range: 5108..5120,
                                        left: BinOp(
                                            ExprBinOp {
                                                range: 5108..5116,
                                                left: Name(
                                                    ExprName {
                                                        range: 5108..5113,
                                                        id: "match",
                                                        ctx: Load,
                                                    },
                                                ),
                                                op: Mult,
                                                right: Name(
                                                    ExprName {
                                                        range: 5115..5116,
                                                        id: "a",
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                        op: Add,
                                        right: Name(
                                            ExprName {
                                                range: 5119..5120,
                                                id: "b",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ),
                                Name(
                                    ExprName {
                                        range: 5122..5123,
                                        id: "c",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5149..5166,
                    value: Tuple(
                        ExprTuple {
                            range: 5149..5166,
                            elts: [
                                BinOp(
                                    ExprBinOp {
                                        range: 5149..5163,
                                        left: Name(
                                            ExprName {
                                                range: 5149..5154,
                                                id: "match",
                                                ctx: Load,
                                            },
                                        ),
                                        op: Mult,
                                        right: BinOp(
                                            ExprBinOp {
                                                range: 5157..5162,
                                                left: Name(
                                                    ExprName {
                                                        range: 5157..5158,
                                                        id: "a",
                                                        ctx: Load,
                                                    },
                                                ),
                                                op: Add,
                                                right: Name(
                                                    ExprName {
                                                        range: 5161..5162,
                                                        id: "b",
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                Name(
                                    ExprName {
                                        range: 5165..5166,
                                        id: "c",
                                        ctx: Load,
                                    },
                                ),
                            ],
                            ctx: Load,
                            parenthesized: false,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5192..5209,
                    value: Call(
                        ExprCall {
                            range: 5192..5209,
                            func: Name(
                                ExprName {
                                    range: 5192..5197,
                                    id: "match",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 5198..5209,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 5199..5205,
                                            value: BinOp(
                                                ExprBinOp {
                                                    range: 5200..5205,
                                                    left: Name(
                                                        ExprName {
                                                            range: 5200..5201,
                                                            id: "a",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    op: Add,
                                                    right: Name(
                                                        ExprName {
                                                            range: 5204..5205,
                                                            id: "b",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                    Name(
                                        ExprName {
                                            range: 5207..5208,
                                            id: "c",
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5236..5252,
                    value: BinOp(
                        ExprBinOp {
                            range: 5236..5252,
                            left: BinOp(
                                ExprBinOp {
                                    range: 5236..5248,
                                    left: Name(
                                        ExprName {
                                            range: 5236..5241,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    op: Sub,
                                    right: BinOp(
                                        ExprBinOp {
                                            range: 5243..5248,
                                            left: Name(
                                                ExprName {
                                                    range: 5243..5244,
                                                    id: "a",
                                                    ctx: Load,
                                                },
                                            ),
                                            op: Mult,
                                            right: Name(
                                                ExprName {
                                                    range: 5247..5248,
                                                    id: "b",
                                                    ctx: Load,
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Add,
                            right: Name(
                                ExprName {
                                    range: 5251..5252,
                                    id: "c",
                                    ctx: Load,
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5279..5297,
                    value: BinOp(
                        ExprBinOp {
                            range: 5279..5297,
                            left: BinOp(
                                ExprBinOp {
                                    range: 5279..5293,
                                    left: Name(
                                        ExprName {
                                            range: 5279..5284,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    op: Sub,
                                    right: BinOp(
                                        ExprBinOp {
                                            range: 5287..5292,
                                            left: Name(
                                                ExprName {
                                                    range: 5287..5288,
                                                    id: "a",
                                                    ctx: Load,
                                                },
                                            ),
                                            op: Mult,
                                            right: Name(
                                                ExprName {
                                                    range: 5291..5292,
                                                    id: "b",
                                                    ctx: Load,
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            op: Add,
                            right: Name(
                                ExprName {
                                    range: 5296..5297,
                                    id: "c",
                                    ctx: Load,
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5324..5342,
                    value: BinOp(
                        ExprBinOp {
                            range: 5324..5342,
                            left: BinOp(
                                ExprBinOp {
                                    range: 5324..5338,
                                    left: Call(
                                        ExprCall {
                                            range: 5324..5334,
                                            func: Name(
                                                ExprName {
                                                    range: 5324..5329,
                                                    id: "match",
                                                    ctx: Load,
                                                },
                                            ),
                                            arguments: Arguments {
                                                range: 5330..5334,
                                                args: [
                                                    UnaryOp(
                                                        ExprUnaryOp {
                                                            range: 5331..5333,
                                                            op: USub,
                                                            operand: Name(
                                                                ExprName {
                                                                    range: 5332..5333,
                                                                    id: "a",
                                                                    ctx: Load,
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                keywords: [],
                                            },
                                        },
                                    ),
                                    op: Mult,
                                    right: Name(
                                        ExprName {
                                            range: 5337..5338,
                                            id: "b",
                                            ctx: Load,
                                        },
                                    ),
                                },
                            ),
                            op: Add,
                            right: Name(
                                ExprName {
                                    range: 5341..5342,
                                    id: "c",
                                    ctx: Load,
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5370..5380,
                    value: Attribute(
                        ExprAttribute {
                            range: 5370..5380,
                            value: Call(
                                ExprCall {
                                    range: 5370..5378,
                                    func: Name(
                                        ExprName {
                                            range: 5370..5375,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: Arguments {
                                        range: 5376..5378,
                                        args: [],
                                        keywords: [],
                                    },
                                },
                            ),
                            attr: Identifier {
                                id: "a",
                                range: 5379..5380,
                            },
                            ctx: Load,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5397..5409,
                    value: Attribute(
                        ExprAttribute {
                            range: 5397..5409,
                            value: Call(
                                ExprCall {
                                    range: 5397..5407,
                                    func: Name(
                                        ExprName {
                                            range: 5397..5402,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: Arguments {
                                        range: 5403..5407,
                                        args: [
                                            Tuple(
                                                ExprTuple {
                                                    range: 5404..5406,
                                                    elts: [],
                                                    ctx: Load,
                                                    parenthesized: true,
                                                },
                                            ),
                                        ],
                                        keywords: [],
                                    },
                                },
                            ),
                            attr: Identifier {
                                id: "a",
                                range: 5408..5409,
                            },
                            ctx: Load,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5428..5441,
                    value: Attribute(
                        ExprAttribute {
                            range: 5428..5441,
                            value: Call(
                                ExprCall {
                                    range: 5428..5439,
                                    func: Name(
                                        ExprName {
                                            range: 5428..5433,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: Arguments {
                                        range: 5434..5439,
                                        args: [
                                            Tuple(
                                                ExprTuple {
                                                    range: 5435..5437,
                                                    elts: [],
                                                    ctx: Load,
                                                    parenthesized: true,
                                                },
                                            ),
                                        ],
                                        keywords: [],
                                    },
                                },
                            ),
                            attr: Identifier {
                                id: "a",
                                range: 5440..5441,
                            },
                            ctx: Load,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5460..5471,
                    value: Attribute(
                        ExprAttribute {
                            range: 5460..5471,
                            value: Subscript(
                                ExprSubscript {
                                    range: 5460..5469,
                                    value: Name(
                                        ExprName {
                                            range: 5460..5465,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    slice: Name(
                                        ExprName {
                                            range: 5467..5468,
                                            id: "a",
                                            ctx: Load,
                                        },
                                    ),
                                    ctx: Load,
                                },
                            ),
                            attr: Identifier {
                                id: "b",
                                range: 5470..5471,
                            },
                            ctx: Load,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5489..5501,
                    value: Attribute(
                        ExprAttribute {
                            range: 5489..5501,
                            value: Subscript(
                                ExprSubscript {
                                    range: 5489..5499,
                                    value: Name(
                                        ExprName {
                                            range: 5489..5494,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    slice: Tuple(
                                        ExprTuple {
                                            range: 5496..5498,
                                            elts: [
                                                Name(
                                                    ExprName {
                                                        range: 5496..5497,
                                                        id: "a",
                                                        ctx: Load,
                                                    },
                                                ),
                                            ],
                                            ctx: Load,
                                            parenthesized: false,
                                        },
                                    ),
                                    ctx: Load,
                                },
                            ),
                            attr: Identifier {
                                id: "b",
                                range: 5500..5501,
                            },
                            ctx: Load,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5542..5556,
                    value: Attribute(
                        ExprAttribute {
                            range: 5542..5556,
                            value: Subscript(
                                ExprSubscript {
                                    range: 5542..5554,
                                    value: Name(
                                        ExprName {
                                            range: 5542..5547,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    slice: Tuple(
                                        ExprTuple {
                                            range: 5549..5553,
                                            elts: [
                                                Name(
                                                    ExprName {
                                                        range: 5550..5551,
                                                        id: "a",
                                                        ctx: Load,
                                                    },
                                                ),
                                            ],
                                            ctx: Load,
                                            parenthesized: true,
                                        },
                                    ),
                                    ctx: Load,
                                },
                            ),
                            attr: Identifier {
                                id: "b",
                                range: 5555..5556,
                            },
                            ctx: Load,
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5577..5594,
                    value: Subscript(
                        ExprSubscript {
                            range: 5577..5594,
                            value: Call(
                                ExprCall {
                                    range: 5577..5584,
                                    func: Name(
                                        ExprName {
                                            range: 5577..5582,
                                            id: "match",
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: Arguments {
                                        range: 5582..5584,
                                        args: [],
                                        keywords: [],
                                    },
                                },
                            ),
                            slice: Slice(
                                ExprSlice {
                                    range: 5585..5593,
                                    lower: Some(
                                        Name(
                                            ExprName {
                                                range: 5585..5586,
                                                id: "a",
                                                ctx: Load,
                                            },
                                        ),
                                    ),
                                    upper: Some(
                                        Name(
                                            ExprName {
                                                range: 5592..5593,
                                                id: "b",
                                                ctx: Load,
                                            },
                                        ),
                                    ),
                                    step: None,
                                },
                            ),
                            ctx: Load,
                        },
                    ),
                },
            ),
            If(
                StmtIf {
                    range: 5614..5633,
                    test: Named(
                        ExprNamed {
                            range: 5617..5627,
                            target: Name(
                                ExprName {
                                    range: 5617..5622,
                                    id: "match",
                                    ctx: Store,
                                },
                            ),
                            value: NumberLiteral(
                                ExprNumberLiteral {
                                    range: 5626..5627,
                                    value: Int(
                                        1,
                                    ),
                                },
                            ),
                        },
                    ),
                    body: [
                        Pass(
                            StmtPass {
                                range: 5629..5633,
                            },
                        ),
                    ],
                    elif_else_clauses: [],
                },
            ),
            Match(
                StmtMatch {
                    range: 5634..5688,
                    subject: Name(
                        ExprName {
                            range: 5640..5645,
                            id: "match",
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 5651..5663,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 5656..5657,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 5656..5657,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Pass(
                                    StmtPass {
                                        range: 5659..5663,
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 5668..5688,
                            pattern: MatchValue(
                                PatternMatchValue {
                                    range: 5673..5674,
                                    value: NumberLiteral(
                                        ExprNumberLiteral {
                                            range: 5673..5674,
                                            value: Int(
                                                2,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            guard: None,
                            body: [
                                Pass(
                                    StmtPass {
                                        range: 5684..5688,
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
            Assign(
                StmtAssign {
                    range: 5689..5725,
                    targets: [
                        Name(
                            ExprName {
                                range: 5689..5694,
                                id: "match",
                                ctx: Store,
                            },
                        ),
                    ],
                    value: Lambda(
                        ExprLambda {
                            range: 5697..5725,
                            parameters: Some(
                                Parameters {
                                    range: 5704..5709,
                                    posonlyargs: [],
                                    args: [
                                        ParameterWithDefault {
                                            range: 5704..5709,
                                            parameter: Parameter {
                                                range: 5704..5709,
                                                name: Identifier {
                                                    id: "query",
                                                    range: 5704..5709,
                                                },
                                                annotation: None,
                                            },
                                            default: None,
                                        },
                                    ],
                                    vararg: None,
                                    kwonlyargs: [],
                                    kwarg: None,
                                },
                            ),
                            body: Compare(
                                ExprCompare {
                                    range: 5711..5725,
                                    left: Name(
                                        ExprName {
                                            range: 5711..5716,
                                            id: "query",
                                            ctx: Load,
                                        },
                                    ),
                                    ops: [
                                        Eq,
                                    ],
                                    comparators: [
                                        Name(
                                            ExprName {
                                                range: 5720..5725,
                                                id: "event",
                                                ctx: Load,
                                            },
                                        ),
                                    ],
                                },
                            ),
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 5726..5742,
                    value: Call(
                        ExprCall {
                            range: 5726..5742,
                            func: Name(
                                ExprName {
                                    range: 5726..5731,
                                    id: "print",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 5731..5742,
                                args: [
                                    Call(
                                        ExprCall {
                                            range: 5732..5741,
                                            func: Name(
                                                ExprName {
                                                    range: 5732..5737,
                                                    id: "match",
                                                    ctx: Load,
                                                },
                                            ),
                                            arguments: Arguments {
                                                range: 5737..5741,
                                                args: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 5738..5740,
                                                            value: Int(
                                                                12,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                keywords: [],
                                            },
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
        ],
    },
)
```
