ruff_python_parser 0.0.2

---
source: crates/ruff_python_parser/tests/fixtures.rs
input_file: crates/ruff_python_parser/resources/inline/err/duplicate_match_key.py
---
## AST

```
Module(
    ModModule {
        node_index: NodeIndex(None),
        range: 0..754,
        body: [
            Match(
                StmtMatch {
                    node_index: NodeIndex(None),
                    range: 0..753,
                    subject: Name(
                        ExprName {
                            node_index: NodeIndex(None),
                            range: 6..7,
                            id: Name("x"),
                            ctx: Load,
                        },
                    ),
                    cases: [
                        MatchCase {
                            range: 13..39,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 18..34,
                                    keys: [
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 19..22,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 19..22,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 27..30,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 27..30,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 24..25,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 24..25,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 32..33,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 32..33,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 36..39,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 36..39,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 44..72,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 49..67,
                                    keys: [
                                        BytesLiteral(
                                            ExprBytesLiteral {
                                                node_index: NodeIndex(None),
                                                range: 50..54,
                                                value: BytesLiteralValue {
                                                    inner: Single(
                                                        BytesLiteral {
                                                            range: 50..54,
                                                            node_index: NodeIndex(None),
                                                            value: [
                                                                120,
                                                            ],
                                                            flags: BytesLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Regular,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        BytesLiteral(
                                            ExprBytesLiteral {
                                                node_index: NodeIndex(None),
                                                range: 59..63,
                                                value: BytesLiteralValue {
                                                    inner: Single(
                                                        BytesLiteral {
                                                            range: 59..63,
                                                            node_index: NodeIndex(None),
                                                            value: [
                                                                120,
                                                            ],
                                                            flags: BytesLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Regular,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 56..57,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 56..57,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 65..66,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 65..66,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 69..72,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 69..72,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 77..99,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 82..94,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 83..84,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 89..90,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 86..87,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 86..87,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 92..93,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 92..93,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 96..99,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 96..99,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 104..130,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 109..125,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 110..113,
                                                value: Float(
                                                    1.0,
                                                ),
                                            },
                                        ),
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 118..121,
                                                value: Float(
                                                    1.0,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 115..116,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 115..116,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 123..124,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 123..124,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 127..130,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 127..130,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 135..171,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 140..166,
                                    keys: [
                                        BinOp(
                                            ExprBinOp {
                                                node_index: NodeIndex(None),
                                                range: 141..149,
                                                left: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 141..144,
                                                        value: Float(
                                                            1.0,
                                                        ),
                                                    },
                                                ),
                                                op: Add,
                                                right: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 147..149,
                                                        value: Complex {
                                                            real: 0.0,
                                                            imag: 2.0,
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                        BinOp(
                                            ExprBinOp {
                                                node_index: NodeIndex(None),
                                                range: 154..162,
                                                left: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 154..157,
                                                        value: Float(
                                                            1.0,
                                                        ),
                                                    },
                                                ),
                                                op: Add,
                                                right: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 160..162,
                                                        value: Complex {
                                                            real: 0.0,
                                                            imag: 2.0,
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 151..152,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 151..152,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 164..165,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 164..165,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 168..171,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 168..171,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 176..204,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 181..199,
                                    keys: [
                                        BooleanLiteral(
                                            ExprBooleanLiteral {
                                                node_index: NodeIndex(None),
                                                range: 182..186,
                                                value: true,
                                            },
                                        ),
                                        BooleanLiteral(
                                            ExprBooleanLiteral {
                                                node_index: NodeIndex(None),
                                                range: 191..195,
                                                value: true,
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 188..189,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 188..189,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 197..198,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 197..198,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 201..204,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 201..204,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 209..237,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 214..232,
                                    keys: [
                                        NoneLiteral(
                                            ExprNoneLiteral {
                                                node_index: NodeIndex(None),
                                                range: 215..219,
                                            },
                                        ),
                                        NoneLiteral(
                                            ExprNoneLiteral {
                                                node_index: NodeIndex(None),
                                                range: 224..228,
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 221..222,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 221..222,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 230..231,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 230..231,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 234..237,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 234..237,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 242..268,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 247..263,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 248..249,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                        BooleanLiteral(
                                            ExprBooleanLiteral {
                                                node_index: NodeIndex(None),
                                                range: 254..259,
                                                value: false,
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 251..252,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 251..252,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 261..262,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 261..262,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 265..268,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 265..268,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 273..300,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 278..295,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 279..282,
                                                value: Float(
                                                    1.0,
                                                ),
                                            },
                                        ),
                                        BooleanLiteral(
                                            ExprBooleanLiteral {
                                                node_index: NodeIndex(None),
                                                range: 287..291,
                                                value: true,
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 284..285,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 284..285,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 293..294,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 293..294,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 297..300,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 297..300,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 305..332,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 310..327,
                                    keys: [
                                        UnaryOp(
                                            ExprUnaryOp {
                                                node_index: NodeIndex(None),
                                                range: 311..313,
                                                op: USub,
                                                operand: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 312..313,
                                                        value: Int(
                                                            0,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        BooleanLiteral(
                                            ExprBooleanLiteral {
                                                node_index: NodeIndex(None),
                                                range: 318..323,
                                                value: false,
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 315..316,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 315..316,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 325..326,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 325..326,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 329..332,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 329..332,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 337..367,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 342..362,
                                    keys: [
                                        BinOp(
                                            ExprBinOp {
                                                node_index: NodeIndex(None),
                                                range: 343..349,
                                                left: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 343..344,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                                op: Add,
                                                right: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 347..349,
                                                        value: Complex {
                                                            real: 0.0,
                                                            imag: 0.0,
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                        BooleanLiteral(
                                            ExprBooleanLiteral {
                                                node_index: NodeIndex(None),
                                                range: 354..358,
                                                value: true,
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 351..352,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 351..352,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 360..361,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 360..361,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 364..367,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 364..367,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 372..449,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 377..444,
                                    keys: [
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 383..407,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 383..407,
                                                            node_index: NodeIndex(None),
                                                            value: "x\n    y\n    z\n    ",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: true,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 416..440,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 416..440,
                                                            node_index: NodeIndex(None),
                                                            value: "x\n    y\n    z\n    ",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: true,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 409..410,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 409..410,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 442..443,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 442..443,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 446..449,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 446..449,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 454..488,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 459..483,
                                    keys: [
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 460..463,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 460..463,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 468..471,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 468..471,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 476..479,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 476..479,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 465..466,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 465..466,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 473..474,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 473..474,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 481..482,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 481..482,
                                                        value: Int(
                                                            3,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 485..488,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 485..488,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 493..531,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 498..526,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 499..500,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 505..508,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 505..508,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 513..514,
                                                value: Int(
                                                    0,
                                                ),
                                            },
                                        ),
                                        StringLiteral(
                                            ExprStringLiteral {
                                                node_index: NodeIndex(None),
                                                range: 519..522,
                                                value: StringLiteralValue {
                                                    inner: Single(
                                                        StringLiteral {
                                                            range: 519..522,
                                                            node_index: NodeIndex(None),
                                                            value: "x",
                                                            flags: StringLiteralFlags {
                                                                quote_style: Double,
                                                                prefix: Empty,
                                                                triple_quoted: false,
                                                                unclosed: false,
                                                            },
                                                        },
                                                    ),
                                                },
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 502..503,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 502..503,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 510..511,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 510..511,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 516..517,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 516..517,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 524..525,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 524..525,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 528..531,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 528..531,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 536..564,
                            node_index: NodeIndex(None),
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    node_index: NodeIndex(None),
                                    range: 541..559,
                                    patterns: [
                                        MatchMapping(
                                            PatternMatchMapping {
                                                node_index: NodeIndex(None),
                                                range: 542..558,
                                                keys: [
                                                    StringLiteral(
                                                        ExprStringLiteral {
                                                            node_index: NodeIndex(None),
                                                            range: 543..546,
                                                            value: StringLiteralValue {
                                                                inner: Single(
                                                                    StringLiteral {
                                                                        range: 543..546,
                                                                        node_index: NodeIndex(None),
                                                                        value: "x",
                                                                        flags: StringLiteralFlags {
                                                                            quote_style: Double,
                                                                            prefix: Empty,
                                                                            triple_quoted: false,
                                                                            unclosed: false,
                                                                        },
                                                                    },
                                                                ),
                                                            },
                                                        },
                                                    ),
                                                    StringLiteral(
                                                        ExprStringLiteral {
                                                            node_index: NodeIndex(None),
                                                            range: 551..554,
                                                            value: StringLiteralValue {
                                                                inner: Single(
                                                                    StringLiteral {
                                                                        range: 551..554,
                                                                        node_index: NodeIndex(None),
                                                                        value: "x",
                                                                        flags: StringLiteralFlags {
                                                                            quote_style: Double,
                                                                            prefix: Empty,
                                                                            triple_quoted: false,
                                                                            unclosed: false,
                                                                        },
                                                                    },
                                                                ),
                                                            },
                                                        },
                                                    ),
                                                ],
                                                patterns: [
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            node_index: NodeIndex(None),
                                                            range: 548..549,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: NodeIndex(None),
                                                                    range: 548..549,
                                                                    value: Int(
                                                                        1,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    MatchValue(
                                                        PatternMatchValue {
                                                            node_index: NodeIndex(None),
                                                            range: 556..557,
                                                            value: NumberLiteral(
                                                                ExprNumberLiteral {
                                                                    node_index: NodeIndex(None),
                                                                    range: 556..557,
                                                                    value: Int(
                                                                        2,
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                rest: None,
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 561..564,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 561..564,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 569..607,
                            node_index: NodeIndex(None),
                            pattern: MatchClass(
                                PatternMatchClass {
                                    node_index: NodeIndex(None),
                                    range: 574..602,
                                    cls: Name(
                                        ExprName {
                                            node_index: NodeIndex(None),
                                            range: 574..577,
                                            id: Name("Foo"),
                                            ctx: Load,
                                        },
                                    ),
                                    arguments: PatternArguments {
                                        range: 577..602,
                                        node_index: NodeIndex(None),
                                        patterns: [],
                                        keywords: [
                                            PatternKeyword {
                                                range: 578..581,
                                                node_index: NodeIndex(None),
                                                attr: Identifier {
                                                    id: Name("x"),
                                                    range: 578..579,
                                                    node_index: NodeIndex(None),
                                                },
                                                pattern: MatchValue(
                                                    PatternMatchValue {
                                                        node_index: NodeIndex(None),
                                                        range: 580..581,
                                                        value: NumberLiteral(
                                                            ExprNumberLiteral {
                                                                node_index: NodeIndex(None),
                                                                range: 580..581,
                                                                value: Int(
                                                                    1,
                                                                ),
                                                            },
                                                        ),
                                                    },
                                                ),
                                            },
                                            PatternKeyword {
                                                range: 583..601,
                                                node_index: NodeIndex(None),
                                                attr: Identifier {
                                                    id: Name("y"),
                                                    range: 583..584,
                                                    node_index: NodeIndex(None),
                                                },
                                                pattern: MatchMapping(
                                                    PatternMatchMapping {
                                                        node_index: NodeIndex(None),
                                                        range: 585..601,
                                                        keys: [
                                                            StringLiteral(
                                                                ExprStringLiteral {
                                                                    node_index: NodeIndex(None),
                                                                    range: 586..589,
                                                                    value: StringLiteralValue {
                                                                        inner: Single(
                                                                            StringLiteral {
                                                                                range: 586..589,
                                                                                node_index: NodeIndex(None),
                                                                                value: "x",
                                                                                flags: StringLiteralFlags {
                                                                                    quote_style: Double,
                                                                                    prefix: Empty,
                                                                                    triple_quoted: false,
                                                                                    unclosed: false,
                                                                                },
                                                                            },
                                                                        ),
                                                                    },
                                                                },
                                                            ),
                                                            StringLiteral(
                                                                ExprStringLiteral {
                                                                    node_index: NodeIndex(None),
                                                                    range: 594..597,
                                                                    value: StringLiteralValue {
                                                                        inner: Single(
                                                                            StringLiteral {
                                                                                range: 594..597,
                                                                                node_index: NodeIndex(None),
                                                                                value: "x",
                                                                                flags: StringLiteralFlags {
                                                                                    quote_style: Double,
                                                                                    prefix: Empty,
                                                                                    triple_quoted: false,
                                                                                    unclosed: false,
                                                                                },
                                                                            },
                                                                        ),
                                                                    },
                                                                },
                                                            ),
                                                        ],
                                                        patterns: [
                                                            MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 591..592,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 591..592,
                                                                            value: Int(
                                                                                1,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                            MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 599..600,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 599..600,
                                                                            value: Int(
                                                                                2,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        ],
                                                        rest: None,
                                                    },
                                                ),
                                            },
                                        ],
                                    },
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 604..607,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 604..607,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 612..662,
                            node_index: NodeIndex(None),
                            pattern: MatchSequence(
                                PatternMatchSequence {
                                    node_index: NodeIndex(None),
                                    range: 617..657,
                                    patterns: [
                                        MatchClass(
                                            PatternMatchClass {
                                                node_index: NodeIndex(None),
                                                range: 618..626,
                                                cls: Name(
                                                    ExprName {
                                                        node_index: NodeIndex(None),
                                                        range: 618..621,
                                                        id: Name("Foo"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                arguments: PatternArguments {
                                                    range: 621..626,
                                                    node_index: NodeIndex(None),
                                                    patterns: [],
                                                    keywords: [
                                                        PatternKeyword {
                                                            range: 622..625,
                                                            node_index: NodeIndex(None),
                                                            attr: Identifier {
                                                                id: Name("x"),
                                                                range: 622..623,
                                                                node_index: NodeIndex(None),
                                                            },
                                                            pattern: MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 624..625,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 624..625,
                                                                            value: Int(
                                                                                1,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                        MatchClass(
                                            PatternMatchClass {
                                                node_index: NodeIndex(None),
                                                range: 628..656,
                                                cls: Name(
                                                    ExprName {
                                                        node_index: NodeIndex(None),
                                                        range: 628..631,
                                                        id: Name("Foo"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                arguments: PatternArguments {
                                                    range: 631..656,
                                                    node_index: NodeIndex(None),
                                                    patterns: [],
                                                    keywords: [
                                                        PatternKeyword {
                                                            range: 632..635,
                                                            node_index: NodeIndex(None),
                                                            attr: Identifier {
                                                                id: Name("x"),
                                                                range: 632..633,
                                                                node_index: NodeIndex(None),
                                                            },
                                                            pattern: MatchValue(
                                                                PatternMatchValue {
                                                                    node_index: NodeIndex(None),
                                                                    range: 634..635,
                                                                    value: NumberLiteral(
                                                                        ExprNumberLiteral {
                                                                            node_index: NodeIndex(None),
                                                                            range: 634..635,
                                                                            value: Int(
                                                                                1,
                                                                            ),
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                        PatternKeyword {
                                                            range: 637..655,
                                                            node_index: NodeIndex(None),
                                                            attr: Identifier {
                                                                id: Name("y"),
                                                                range: 637..638,
                                                                node_index: NodeIndex(None),
                                                            },
                                                            pattern: MatchMapping(
                                                                PatternMatchMapping {
                                                                    node_index: NodeIndex(None),
                                                                    range: 639..655,
                                                                    keys: [
                                                                        StringLiteral(
                                                                            ExprStringLiteral {
                                                                                node_index: NodeIndex(None),
                                                                                range: 640..643,
                                                                                value: StringLiteralValue {
                                                                                    inner: Single(
                                                                                        StringLiteral {
                                                                                            range: 640..643,
                                                                                            node_index: NodeIndex(None),
                                                                                            value: "x",
                                                                                            flags: StringLiteralFlags {
                                                                                                quote_style: Double,
                                                                                                prefix: Empty,
                                                                                                triple_quoted: false,
                                                                                                unclosed: false,
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            },
                                                                        ),
                                                                        StringLiteral(
                                                                            ExprStringLiteral {
                                                                                node_index: NodeIndex(None),
                                                                                range: 648..651,
                                                                                value: StringLiteralValue {
                                                                                    inner: Single(
                                                                                        StringLiteral {
                                                                                            range: 648..651,
                                                                                            node_index: NodeIndex(None),
                                                                                            value: "x",
                                                                                            flags: StringLiteralFlags {
                                                                                                quote_style: Double,
                                                                                                prefix: Empty,
                                                                                                triple_quoted: false,
                                                                                                unclosed: false,
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            },
                                                                        ),
                                                                    ],
                                                                    patterns: [
                                                                        MatchValue(
                                                                            PatternMatchValue {
                                                                                node_index: NodeIndex(None),
                                                                                range: 645..646,
                                                                                value: NumberLiteral(
                                                                                    ExprNumberLiteral {
                                                                                        node_index: NodeIndex(None),
                                                                                        range: 645..646,
                                                                                        value: Int(
                                                                                            1,
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ),
                                                                        MatchValue(
                                                                            PatternMatchValue {
                                                                                node_index: NodeIndex(None),
                                                                                range: 653..654,
                                                                                value: NumberLiteral(
                                                                                    ExprNumberLiteral {
                                                                                        node_index: NodeIndex(None),
                                                                                        range: 653..654,
                                                                                        value: Int(
                                                                                            2,
                                                                                        ),
                                                                                    },
                                                                                ),
                                                                            },
                                                                        ),
                                                                    ],
                                                                    rest: None,
                                                                },
                                                            ),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                    ],
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 659..662,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 659..662,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 667..691,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 672..686,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 673..674,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 679..682,
                                                value: Float(
                                                    2.0,
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 676..677,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 676..677,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 684..685,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 684..685,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 688..691,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 688..691,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                        MatchCase {
                            range: 696..753,
                            node_index: NodeIndex(None),
                            pattern: MatchMapping(
                                PatternMatchMapping {
                                    node_index: NodeIndex(None),
                                    range: 701..748,
                                    keys: [
                                        NumberLiteral(
                                            ExprNumberLiteral {
                                                node_index: NodeIndex(None),
                                                range: 702..718,
                                                value: Int(
                                                    9007199254740993,
                                                ),
                                            },
                                        ),
                                        BinOp(
                                            ExprBinOp {
                                                node_index: NodeIndex(None),
                                                range: 723..744,
                                                left: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 723..739,
                                                        value: Int(
                                                            9007199254740993,
                                                        ),
                                                    },
                                                ),
                                                op: Add,
                                                right: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 742..744,
                                                        value: Complex {
                                                            real: 0.0,
                                                            imag: 0.0,
                                                        },
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    patterns: [
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 720..721,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 720..721,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                        MatchValue(
                                            PatternMatchValue {
                                                node_index: NodeIndex(None),
                                                range: 746..747,
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: NodeIndex(None),
                                                        range: 746..747,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    rest: None,
                                },
                            ),
                            guard: None,
                            body: [
                                Expr(
                                    StmtExpr {
                                        node_index: NodeIndex(None),
                                        range: 750..753,
                                        value: EllipsisLiteral(
                                            ExprEllipsisLiteral {
                                                node_index: NodeIndex(None),
                                                range: 750..753,
                                            },
                                        ),
                                    },
                                ),
                            ],
                        },
                    ],
                },
            ),
        ],
    },
)
```
## Semantic Syntax Errors

  |
1 | match x:
2 |     case {"x": 1, "x": 2}: ...
  |                   ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
3 |     case {b"x": 1, b"x": 2}: ...
4 |     case {0: 1, 0: 2}: ...
  |


  |
1 | match x:
2 |     case {"x": 1, "x": 2}: ...
3 |     case {b"x": 1, b"x": 2}: ...
  |                    ^^^^ Syntax Error: mapping pattern checks duplicate key `b"x"`
4 |     case {0: 1, 0: 2}: ...
5 |     case {1.0: 1, 1.0: 2}: ...
  |


  |
2 |     case {"x": 1, "x": 2}: ...
3 |     case {b"x": 1, b"x": 2}: ...
4 |     case {0: 1, 0: 2}: ...
  |                 ^ Syntax Error: mapping pattern checks duplicate key `0`
5 |     case {1.0: 1, 1.0: 2}: ...
6 |     case {1.0 + 2j: 1, 1.0 + 2j: 2}: ...
  |


  |
3 |     case {b"x": 1, b"x": 2}: ...
4 |     case {0: 1, 0: 2}: ...
5 |     case {1.0: 1, 1.0: 2}: ...
  |                   ^^^ Syntax Error: mapping pattern checks duplicate key `1.0`
6 |     case {1.0 + 2j: 1, 1.0 + 2j: 2}: ...
7 |     case {True: 1, True: 2}: ...
  |


  |
4 |     case {0: 1, 0: 2}: ...
5 |     case {1.0: 1, 1.0: 2}: ...
6 |     case {1.0 + 2j: 1, 1.0 + 2j: 2}: ...
  |                        ^^^^^^^^ Syntax Error: mapping pattern checks duplicate key `1.0 + 2j`
7 |     case {True: 1, True: 2}: ...
8 |     case {None: 1, None: 2}: ...
  |


  |
5 |     case {1.0: 1, 1.0: 2}: ...
6 |     case {1.0 + 2j: 1, 1.0 + 2j: 2}: ...
7 |     case {True: 1, True: 2}: ...
  |                    ^^^^ Syntax Error: mapping pattern checks duplicate key `True`
8 |     case {None: 1, None: 2}: ...
9 |     case {0: 1, False: 2}: ...
  |


   |
 6 |     case {1.0 + 2j: 1, 1.0 + 2j: 2}: ...
 7 |     case {True: 1, True: 2}: ...
 8 |     case {None: 1, None: 2}: ...
   |                    ^^^^ Syntax Error: mapping pattern checks duplicate key `None`
 9 |     case {0: 1, False: 2}: ...
10 |     case {1.0: 1, True: 2}: ...
   |


   |
 7 |     case {True: 1, True: 2}: ...
 8 |     case {None: 1, None: 2}: ...
 9 |     case {0: 1, False: 2}: ...
   |                 ^^^^^ Syntax Error: mapping pattern checks duplicate key `False`
10 |     case {1.0: 1, True: 2}: ...
11 |     case {-0: 1, False: 2}: ...
   |


   |
 8 |     case {None: 1, None: 2}: ...
 9 |     case {0: 1, False: 2}: ...
10 |     case {1.0: 1, True: 2}: ...
   |                   ^^^^ Syntax Error: mapping pattern checks duplicate key `True`
11 |     case {-0: 1, False: 2}: ...
12 |     case {1 + 0j: 1, True: 2}: ...
   |


   |
 9 |     case {0: 1, False: 2}: ...
10 |     case {1.0: 1, True: 2}: ...
11 |     case {-0: 1, False: 2}: ...
   |                  ^^^^^ Syntax Error: mapping pattern checks duplicate key `False`
12 |     case {1 + 0j: 1, True: 2}: ...
13 |     case {
   |


   |
10 |     case {1.0: 1, True: 2}: ...
11 |     case {-0: 1, False: 2}: ...
12 |     case {1 + 0j: 1, True: 2}: ...
   |                      ^^^^ Syntax Error: mapping pattern checks duplicate key `True`
13 |     case {
14 |     """x
   |


   |
16 |       z
17 |       """: 1,
18 | /     """x
19 | |     y
20 | |     z
21 | |     """: 2}: ...
   | |_______^ Syntax Error: mapping pattern checks duplicate key `"""x\n    y\n    z\n    """`
22 |       case {"x": 1, "x": 2, "x": 3}: ...
23 |       case {0: 1, "x": 1, 0: 2, "x": 2}: ...
   |


   |
20 |     z
21 |     """: 2}: ...
22 |     case {"x": 1, "x": 2, "x": 3}: ...
   |                   ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
23 |     case {0: 1, "x": 1, 0: 2, "x": 2}: ...
24 |     case [{"x": 1, "x": 2}]: ...
   |


   |
20 |     z
21 |     """: 2}: ...
22 |     case {"x": 1, "x": 2, "x": 3}: ...
   |                           ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
23 |     case {0: 1, "x": 1, 0: 2, "x": 2}: ...
24 |     case [{"x": 1, "x": 2}]: ...
   |


   |
21 |     """: 2}: ...
22 |     case {"x": 1, "x": 2, "x": 3}: ...
23 |     case {0: 1, "x": 1, 0: 2, "x": 2}: ...
   |                         ^ Syntax Error: mapping pattern checks duplicate key `0`
24 |     case [{"x": 1, "x": 2}]: ...
25 |     case Foo(x=1, y={"x": 1, "x": 2}): ...
   |


   |
21 |     """: 2}: ...
22 |     case {"x": 1, "x": 2, "x": 3}: ...
23 |     case {0: 1, "x": 1, 0: 2, "x": 2}: ...
   |                               ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
24 |     case [{"x": 1, "x": 2}]: ...
25 |     case Foo(x=1, y={"x": 1, "x": 2}): ...
   |


   |
22 |     case {"x": 1, "x": 2, "x": 3}: ...
23 |     case {0: 1, "x": 1, 0: 2, "x": 2}: ...
24 |     case [{"x": 1, "x": 2}]: ...
   |                    ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
25 |     case Foo(x=1, y={"x": 1, "x": 2}): ...
26 |     case [Foo(x=1), Foo(x=1, y={"x": 1, "x": 2})]: ...
   |


   |
23 |     case {0: 1, "x": 1, 0: 2, "x": 2}: ...
24 |     case [{"x": 1, "x": 2}]: ...
25 |     case Foo(x=1, y={"x": 1, "x": 2}): ...
   |                              ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
26 |     case [Foo(x=1), Foo(x=1, y={"x": 1, "x": 2})]: ...
27 |     case {2: 1, 2.0: 2}: ...
   |


   |
24 |     case [{"x": 1, "x": 2}]: ...
25 |     case Foo(x=1, y={"x": 1, "x": 2}): ...
26 |     case [Foo(x=1), Foo(x=1, y={"x": 1, "x": 2})]: ...
   |                                         ^^^ Syntax Error: mapping pattern checks duplicate key `"x"`
27 |     case {2: 1, 2.0: 2}: ...
28 |     case {9007199254740993: 1, 9007199254740993 + 0j: 2}: ...
   |


   |
25 |     case Foo(x=1, y={"x": 1, "x": 2}): ...
26 |     case [Foo(x=1), Foo(x=1, y={"x": 1, "x": 2})]: ...
27 |     case {2: 1, 2.0: 2}: ...
   |                 ^^^ Syntax Error: mapping pattern checks duplicate key `2.0`
28 |     case {9007199254740993: 1, 9007199254740993 + 0j: 2}: ...
   |