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

```
Module(
    ModModule {
        node_index: AtomicNodeIndex(..),
        range: 0..589,
        body: [
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 0..22,
                    value: SetComp(
                        ExprSetComp {
                            node_index: AtomicNodeIndex(..),
                            range: 0..22,
                            elt: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 1..2,
                                    id: Name("y"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 3..21,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 7..8,
                                            id: Name("y"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Tuple(
                                        ExprTuple {
                                            node_index: AtomicNodeIndex(..),
                                            range: 12..21,
                                            elts: [
                                                NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 13..14,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                                NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 16..17,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                                NumberLiteral(
                                                    ExprNumberLiteral {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 19..20,
                                                        value: Int(
                                                            3,
                                                        ),
                                                    },
                                                ),
                                            ],
                                            ctx: Load,
                                            parenthesized: true,
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 23..42,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 23..42,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 24..26,
                                    id: Name("x1"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 28..30,
                                    id: Name("x2"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 31..41,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 35..36,
                                            id: Name("y"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 40..41,
                                            id: Name("z"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 43..73,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 43..73,
                            key: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 44..49,
                                    left: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 44..45,
                                            id: Name("x"),
                                            ctx: Load,
                                        },
                                    ),
                                    op: Add,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 48..49,
                                            value: Int(
                                                1,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            value: StringLiteral(
                                ExprStringLiteral {
                                    node_index: AtomicNodeIndex(..),
                                    range: 51..54,
                                    value: StringLiteralValue {
                                        inner: Single(
                                            StringLiteral {
                                                range: 51..54,
                                                node_index: AtomicNodeIndex(..),
                                                value: "x",
                                                flags: StringLiteralFlags {
                                                    quote_style: Single,
                                                    prefix: Empty,
                                                    triple_quoted: false,
                                                },
                                            },
                                        ),
                                    },
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 55..72,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 59..60,
                                            id: Name("i"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Call(
                                        ExprCall {
                                            node_index: AtomicNodeIndex(..),
                                            range: 64..72,
                                            func: Name(
                                                ExprName {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 64..69,
                                                    id: Name("range"),
                                                    ctx: Load,
                                                },
                                            ),
                                            arguments: Arguments {
                                                range: 69..72,
                                                node_index: AtomicNodeIndex(..),
                                                args: [
                                                    NumberLiteral(
                                                        ExprNumberLiteral {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 70..71,
                                                            value: Int(
                                                                5,
                                                            ),
                                                        },
                                                    ),
                                                ],
                                                keywords: [],
                                            },
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 74..122,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 74..122,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 75..76,
                                    id: Name("b"),
                                    ctx: Load,
                                },
                            ),
                            value: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 78..83,
                                    left: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 78..79,
                                            id: Name("c"),
                                            ctx: Load,
                                        },
                                    ),
                                    op: Mult,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 82..83,
                                            value: Int(
                                                2,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 84..121,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 88..89,
                                            id: Name("c"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 93..94,
                                            id: Name("d"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        Compare(
                                            ExprCompare {
                                                node_index: AtomicNodeIndex(..),
                                                range: 98..104,
                                                left: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 98..99,
                                                        id: Name("x"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                ops: [
                                                    In,
                                                ],
                                                comparators: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 103..104,
                                                            id: Name("w"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 108..116,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 108..109,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 114..116,
                                                            id: Name("yy"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                        Name(
                                            ExprName {
                                                node_index: AtomicNodeIndex(..),
                                                range: 120..121,
                                                id: Name("z"),
                                                ctx: Load,
                                            },
                                        ),
                                    ],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 123..176,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 123..176,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 124..125,
                                    id: Name("a"),
                                    ctx: Load,
                                },
                            ),
                            value: BinOp(
                                ExprBinOp {
                                    node_index: AtomicNodeIndex(..),
                                    range: 127..133,
                                    left: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 127..128,
                                            id: Name("a"),
                                            ctx: Load,
                                        },
                                    ),
                                    op: Pow,
                                    right: NumberLiteral(
                                        ExprNumberLiteral {
                                            node_index: AtomicNodeIndex(..),
                                            range: 132..133,
                                            value: Int(
                                                2,
                                            ),
                                        },
                                    ),
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 134..155,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 138..139,
                                            id: Name("b"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 143..144,
                                            id: Name("c"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 148..155,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 148..149,
                                                            id: Name("d"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 154..155,
                                                            id: Name("e"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                    is_async: false,
                                },
                                Comprehension {
                                    range: 156..175,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 160..161,
                                            id: Name("f"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 165..166,
                                            id: Name("j"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        Compare(
                                            ExprCompare {
                                                node_index: AtomicNodeIndex(..),
                                                range: 170..175,
                                                left: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 170..171,
                                                        id: Name("k"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                ops: [
                                                    Gt,
                                                ],
                                                comparators: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 174..175,
                                                            id: Name("h"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 177..231,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 177..231,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 178..179,
                                    id: Name("a"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 181..182,
                                    id: Name("b"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 183..204,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 187..188,
                                            id: Name("b"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 192..193,
                                            id: Name("c"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        BoolOp(
                                            ExprBoolOp {
                                                node_index: AtomicNodeIndex(..),
                                                range: 197..204,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 197..198,
                                                            id: Name("d"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 203..204,
                                                            id: Name("e"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                    is_async: false,
                                },
                                Comprehension {
                                    range: 205..230,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 215..216,
                                            id: Name("f"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 220..221,
                                            id: Name("j"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        Compare(
                                            ExprCompare {
                                                node_index: AtomicNodeIndex(..),
                                                range: 225..230,
                                                left: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 225..226,
                                                        id: Name("k"),
                                                        ctx: Load,
                                                    },
                                                ),
                                                ops: [
                                                    Gt,
                                                ],
                                                comparators: [
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 229..230,
                                                            id: Name("h"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    ],
                                    is_async: true,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 232..252,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 232..252,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 233..234,
                                    id: Name("a"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 236..237,
                                    id: Name("a"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 238..251,
                                    node_index: AtomicNodeIndex(..),
                                    target: Tuple(
                                        ExprTuple {
                                            node_index: AtomicNodeIndex(..),
                                            range: 242..246,
                                            elts: [
                                                Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 242..243,
                                                        id: Name("b"),
                                                        ctx: Store,
                                                    },
                                                ),
                                                Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 245..246,
                                                        id: Name("c"),
                                                        ctx: Store,
                                                    },
                                                ),
                                            ],
                                            ctx: Store,
                                            parenthesized: false,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 250..251,
                                            id: Name("d"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 391..416,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 391..416,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 392..393,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 395..396,
                                    id: Name("y"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 397..415,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 401..402,
                                            id: Name("x"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Yield(
                                        ExprYield {
                                            node_index: AtomicNodeIndex(..),
                                            range: 407..414,
                                            value: Some(
                                                Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 413..414,
                                                        id: Name("y"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            ),
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 417..447,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 417..447,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 418..419,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 421..422,
                                    id: Name("y"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 423..446,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 427..428,
                                            id: Name("x"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: YieldFrom(
                                        ExprYieldFrom {
                                            node_index: AtomicNodeIndex(..),
                                            range: 433..445,
                                            value: Name(
                                                ExprName {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 444..445,
                                                    id: Name("y"),
                                                    ctx: Load,
                                                },
                                            ),
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 448..477,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 448..477,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 449..450,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 452..453,
                                    id: Name("y"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 454..476,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 458..459,
                                            id: Name("x"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Lambda(
                                        ExprLambda {
                                            node_index: AtomicNodeIndex(..),
                                            range: 464..475,
                                            parameters: Some(
                                                Parameters {
                                                    range: 471..472,
                                                    node_index: AtomicNodeIndex(
                                                        0,
                                                    ),
                                                    posonlyargs: [],
                                                    args: [
                                                        ParameterWithDefault {
                                                            range: 471..472,
                                                            node_index: AtomicNodeIndex(..),
                                                            parameter: Parameter {
                                                                range: 471..472,
                                                                node_index: AtomicNodeIndex(..),
                                                                name: Identifier {
                                                                    id: Name("y"),
                                                                    range: 471..472,
                                                                    node_index: AtomicNodeIndex(..),
                                                                },
                                                                annotation: None,
                                                            },
                                                            default: None,
                                                        },
                                                    ],
                                                    vararg: None,
                                                    kwonlyargs: [],
                                                    kwarg: None,
                                                },
                                            ),
                                            body: Name(
                                                ExprName {
                                                    node_index: AtomicNodeIndex(..),
                                                    range: 474..475,
                                                    id: Name("y"),
                                                    ctx: Load,
                                                },
                                            ),
                                        },
                                    ),
                                    ifs: [],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 478..511,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 478..511,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 479..480,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 482..483,
                                    id: Name("y"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 484..510,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 488..489,
                                            id: Name("x"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 493..497,
                                            id: Name("data"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        Yield(
                                            ExprYield {
                                                node_index: AtomicNodeIndex(..),
                                                range: 502..509,
                                                value: Some(
                                                    Name(
                                                        ExprName {
                                                            node_index: AtomicNodeIndex(..),
                                                            range: 508..509,
                                                            id: Name("y"),
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ),
                                            },
                                        ),
                                    ],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 512..550,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 512..550,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 513..514,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 516..517,
                                    id: Name("y"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 518..549,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 522..523,
                                            id: Name("x"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 527..531,
                                            id: Name("data"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        YieldFrom(
                                            ExprYieldFrom {
                                                node_index: AtomicNodeIndex(..),
                                                range: 536..548,
                                                value: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 547..548,
                                                        id: Name("y"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    node_index: AtomicNodeIndex(..),
                    range: 551..588,
                    value: DictComp(
                        ExprDictComp {
                            node_index: AtomicNodeIndex(..),
                            range: 551..588,
                            key: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 552..553,
                                    id: Name("x"),
                                    ctx: Load,
                                },
                            ),
                            value: Name(
                                ExprName {
                                    node_index: AtomicNodeIndex(..),
                                    range: 555..556,
                                    id: Name("y"),
                                    ctx: Load,
                                },
                            ),
                            generators: [
                                Comprehension {
                                    range: 557..587,
                                    node_index: AtomicNodeIndex(..),
                                    target: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 561..562,
                                            id: Name("x"),
                                            ctx: Store,
                                        },
                                    ),
                                    iter: Name(
                                        ExprName {
                                            node_index: AtomicNodeIndex(..),
                                            range: 566..570,
                                            id: Name("data"),
                                            ctx: Load,
                                        },
                                    ),
                                    ifs: [
                                        Lambda(
                                            ExprLambda {
                                                node_index: AtomicNodeIndex(..),
                                                range: 575..586,
                                                parameters: Some(
                                                    Parameters {
                                                        range: 582..583,
                                                        node_index: AtomicNodeIndex(
                                                            0,
                                                        ),
                                                        posonlyargs: [],
                                                        args: [
                                                            ParameterWithDefault {
                                                                range: 582..583,
                                                                node_index: AtomicNodeIndex(..),
                                                                parameter: Parameter {
                                                                    range: 582..583,
                                                                    node_index: AtomicNodeIndex(..),
                                                                    name: Identifier {
                                                                        id: Name("y"),
                                                                        range: 582..583,
                                                                        node_index: AtomicNodeIndex(..),
                                                                    },
                                                                    annotation: None,
                                                                },
                                                                default: None,
                                                            },
                                                        ],
                                                        vararg: None,
                                                        kwonlyargs: [],
                                                        kwarg: None,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        node_index: AtomicNodeIndex(..),
                                                        range: 585..586,
                                                        id: Name("y"),
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    is_async: false,
                                },
                            ],
                        },
                    ),
                },
            ),
        ],
    },
)
```
