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

```
Module(
    ModModule {
        range: 0..805,
        body: [
            Expr(
                StmtExpr {
                    range: 102..108,
                    value: Call(
                        ExprCall {
                            range: 102..108,
                            func: Name(
                                ExprName {
                                    range: 102..106,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 106..108,
                                args: [],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 109..119,
                    value: Call(
                        ExprCall {
                            range: 109..119,
                            func: Name(
                                ExprName {
                                    range: 109..113,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 113..119,
                                args: [
                                    Name(
                                        ExprName {
                                            range: 114..115,
                                            id: "x",
                                            ctx: Load,
                                        },
                                    ),
                                    Name(
                                        ExprName {
                                            range: 117..118,
                                            id: "y",
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 120..131,
                    value: Call(
                        ExprCall {
                            range: 120..131,
                            func: Name(
                                ExprName {
                                    range: 120..124,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 124..131,
                                args: [
                                    Name(
                                        ExprName {
                                            range: 125..126,
                                            id: "x",
                                            ctx: Load,
                                        },
                                    ),
                                    Name(
                                        ExprName {
                                            range: 128..129,
                                            id: "y",
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 150..164,
                    value: Call(
                        ExprCall {
                            range: 150..164,
                            func: Name(
                                ExprName {
                                    range: 150..154,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 154..164,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 155..158,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 155..156,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 157..158,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                    Keyword {
                                        range: 160..163,
                                        arg: Some(
                                            Identifier {
                                                id: "y",
                                                range: 160..161,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 162..163,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 165..173,
                    value: Call(
                        ExprCall {
                            range: 165..173,
                            func: Name(
                                ExprName {
                                    range: 165..169,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 169..173,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 170..172,
                                            value: Name(
                                                ExprName {
                                                    range: 171..172,
                                                    id: "x",
                                                    ctx: Load,
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 174..183,
                    value: Call(
                        ExprCall {
                            range: 174..183,
                            func: Name(
                                ExprName {
                                    range: 174..178,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 178..183,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 179..182,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 181..182,
                                                id: "x",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 193..205,
                    value: Call(
                        ExprCall {
                            range: 193..205,
                            func: Name(
                                ExprName {
                                    range: 193..197,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 197..205,
                                args: [
                                    Name(
                                        ExprName {
                                            range: 198..199,
                                            id: "x",
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [
                                    Keyword {
                                        range: 201..204,
                                        arg: Some(
                                            Identifier {
                                                id: "y",
                                                range: 201..202,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 203..204,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 206..217,
                    value: Call(
                        ExprCall {
                            range: 206..217,
                            func: Name(
                                ExprName {
                                    range: 206..210,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 210..217,
                                args: [
                                    Name(
                                        ExprName {
                                            range: 211..212,
                                            id: "x",
                                            ctx: Load,
                                        },
                                    ),
                                    Starred(
                                        ExprStarred {
                                            range: 214..216,
                                            value: Name(
                                                ExprName {
                                                    range: 215..216,
                                                    id: "y",
                                                    ctx: Load,
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 218..230,
                    value: Call(
                        ExprCall {
                            range: 218..230,
                            func: Name(
                                ExprName {
                                    range: 218..222,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 222..230,
                                args: [
                                    Name(
                                        ExprName {
                                            range: 223..224,
                                            id: "x",
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [
                                    Keyword {
                                        range: 226..229,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 228..229,
                                                id: "y",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 231..244,
                    value: Call(
                        ExprCall {
                            range: 231..244,
                            func: Name(
                                ExprName {
                                    range: 231..235,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 235..244,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 241..243,
                                            value: Name(
                                                ExprName {
                                                    range: 242..243,
                                                    id: "y",
                                                    ctx: Load,
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [
                                    Keyword {
                                        range: 236..239,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 236..237,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 238..239,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 245..259,
                    value: Call(
                        ExprCall {
                            range: 245..259,
                            func: Name(
                                ExprName {
                                    range: 245..249,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 249..259,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 250..253,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 250..251,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 252..253,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                    Keyword {
                                        range: 255..258,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 257..258,
                                                id: "y",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 260..273,
                    value: Call(
                        ExprCall {
                            range: 260..273,
                            func: Name(
                                ExprName {
                                    range: 260..264,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 264..273,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 265..267,
                                            value: Name(
                                                ExprName {
                                                    range: 266..267,
                                                    id: "x",
                                                    ctx: Load,
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [
                                    Keyword {
                                        range: 269..272,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 271..272,
                                                id: "y",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 274..288,
                    value: Call(
                        ExprCall {
                            range: 274..288,
                            func: Name(
                                ExprName {
                                    range: 274..278,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 278..288,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 279..281,
                                            value: Name(
                                                ExprName {
                                                    range: 280..281,
                                                    id: "x",
                                                    ctx: Load,
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                    Name(
                                        ExprName {
                                            range: 283..284,
                                            id: "y",
                                            ctx: Load,
                                        },
                                    ),
                                    Name(
                                        ExprName {
                                            range: 286..287,
                                            id: "z",
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 289..308,
                    value: Call(
                        ExprCall {
                            range: 289..308,
                            func: Name(
                                ExprName {
                                    range: 289..293,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 293..308,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 294..297,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 296..297,
                                                id: "x",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                    Keyword {
                                        range: 299..302,
                                        arg: Some(
                                            Identifier {
                                                id: "y",
                                                range: 299..300,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 301..302,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                    Keyword {
                                        range: 304..307,
                                        arg: Some(
                                            Identifier {
                                                id: "z",
                                                range: 304..305,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 306..307,
                                                value: Int(
                                                    2,
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 309..335,
                    value: Call(
                        ExprCall {
                            range: 309..335,
                            func: Name(
                                ExprName {
                                    range: 309..313,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 313..335,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 314..317,
                                            value: Name(
                                                ExprName {
                                                    range: 315..317,
                                                    id: "x1",
                                                    ctx: Load,
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                    Starred(
                                        ExprStarred {
                                            range: 319..322,
                                            value: Name(
                                                ExprName {
                                                    range: 320..322,
                                                    id: "x2",
                                                    ctx: Load,
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [
                                    Keyword {
                                        range: 324..328,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 326..328,
                                                id: "y1",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                    Keyword {
                                        range: 330..334,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 332..334,
                                                id: "y2",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 336..355,
                    value: Call(
                        ExprCall {
                            range: 336..355,
                            func: Name(
                                ExprName {
                                    range: 336..340,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 340..355,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 341..344,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 341..342,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 343..344,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                    Keyword {
                                        range: 346..349,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 348..349,
                                                id: "y",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                    Keyword {
                                        range: 351..354,
                                        arg: Some(
                                            Identifier {
                                                id: "z",
                                                range: 351..352,
                                            },
                                        ),
                                        value: NumberLiteral(
                                            ExprNumberLiteral {
                                                range: 353..354,
                                                value: Int(
                                                    1,
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 378..402,
                    value: Call(
                        ExprCall {
                            range: 378..402,
                            func: Name(
                                ExprName {
                                    range: 378..382,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 382..402,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 383..401,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 383..384,
                                            },
                                        ),
                                        value: If(
                                            ExprIf {
                                                range: 385..401,
                                                test: BooleanLiteral(
                                                    ExprBooleanLiteral {
                                                        range: 390..394,
                                                        value: true,
                                                    },
                                                ),
                                                body: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 385..386,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                                orelse: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 400..401,
                                                        value: Int(
                                                            2,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 403..418,
                    value: Call(
                        ExprCall {
                            range: 403..418,
                            func: Name(
                                ExprName {
                                    range: 403..407,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 407..418,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 408..417,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 408..409,
                                            },
                                        ),
                                        value: Await(
                                            ExprAwait {
                                                range: 410..417,
                                                value: Name(
                                                    ExprName {
                                                        range: 416..417,
                                                        id: "y",
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 419..438,
                    value: Call(
                        ExprCall {
                            range: 419..438,
                            func: Name(
                                ExprName {
                                    range: 419..423,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 423..438,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 424..437,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 424..425,
                                            },
                                        ),
                                        value: Lambda(
                                            ExprLambda {
                                                range: 426..437,
                                                parameters: Some(
                                                    Parameters {
                                                        range: 433..434,
                                                        posonlyargs: [],
                                                        args: [
                                                            ParameterWithDefault {
                                                                range: 433..434,
                                                                parameter: Parameter {
                                                                    range: 433..434,
                                                                    name: Identifier {
                                                                        id: "y",
                                                                        range: 433..434,
                                                                    },
                                                                    annotation: None,
                                                                },
                                                                default: None,
                                                            },
                                                        ],
                                                        vararg: None,
                                                        kwonlyargs: [],
                                                        kwarg: None,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        range: 436..437,
                                                        id: "y",
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 439..455,
                    value: Call(
                        ExprCall {
                            range: 439..455,
                            func: Name(
                                ExprName {
                                    range: 439..443,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 443..455,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 444..454,
                                        arg: Some(
                                            Identifier {
                                                id: "x",
                                                range: 444..445,
                                            },
                                        ),
                                        value: Named(
                                            ExprNamed {
                                                range: 447..453,
                                                target: Name(
                                                    ExprName {
                                                        range: 447..448,
                                                        id: "y",
                                                        ctx: Store,
                                                    },
                                                ),
                                                value: NumberLiteral(
                                                    ExprNumberLiteral {
                                                        range: 452..453,
                                                        value: Int(
                                                            1,
                                                        ),
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 476..491,
                    value: Call(
                        ExprCall {
                            range: 476..491,
                            func: Name(
                                ExprName {
                                    range: 476..480,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 480..491,
                                args: [
                                    Yield(
                                        ExprYield {
                                            range: 482..489,
                                            value: Some(
                                                Name(
                                                    ExprName {
                                                        range: 488..489,
                                                        id: "x",
                                                        ctx: Load,
                                                    },
                                                ),
                                            ),
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 492..512,
                    value: Call(
                        ExprCall {
                            range: 492..512,
                            func: Name(
                                ExprName {
                                    range: 492..496,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 496..512,
                                args: [
                                    YieldFrom(
                                        ExprYieldFrom {
                                            range: 498..510,
                                            value: Name(
                                                ExprName {
                                                    range: 509..510,
                                                    id: "x",
                                                    ctx: Load,
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 533..545,
                    value: Call(
                        ExprCall {
                            range: 533..545,
                            func: Name(
                                ExprName {
                                    range: 533..537,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 537..545,
                                args: [
                                    Named(
                                        ExprNamed {
                                            range: 538..544,
                                            target: Name(
                                                ExprName {
                                                    range: 538..539,
                                                    id: "x",
                                                    ctx: Store,
                                                },
                                            ),
                                            value: NumberLiteral(
                                                ExprNumberLiteral {
                                                    range: 543..544,
                                                    value: Int(
                                                        1,
                                                    ),
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 546..572,
                    value: Call(
                        ExprCall {
                            range: 546..572,
                            func: Name(
                                ExprName {
                                    range: 546..550,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 550..572,
                                args: [
                                    Generator(
                                        ExprGenerator {
                                            range: 551..571,
                                            elt: Named(
                                                ExprNamed {
                                                    range: 551..557,
                                                    target: Name(
                                                        ExprName {
                                                            range: 551..552,
                                                            id: "x",
                                                            ctx: Store,
                                                        },
                                                    ),
                                                    value: NumberLiteral(
                                                        ExprNumberLiteral {
                                                            range: 556..557,
                                                            value: Int(
                                                                1,
                                                            ),
                                                        },
                                                    ),
                                                },
                                            ),
                                            generators: [
                                                Comprehension {
                                                    range: 558..571,
                                                    target: Name(
                                                        ExprName {
                                                            range: 562..563,
                                                            id: "x",
                                                            ctx: Store,
                                                        },
                                                    ),
                                                    iter: Name(
                                                        ExprName {
                                                            range: 567..571,
                                                            id: "iter",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    ifs: [],
                                                    is_async: false,
                                                },
                                            ],
                                            parenthesized: false,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 596..610,
                    value: Call(
                        ExprCall {
                            range: 596..610,
                            func: Name(
                                ExprName {
                                    range: 596..600,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 600..610,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 601..609,
                                            value: BoolOp(
                                                ExprBoolOp {
                                                    range: 602..609,
                                                    op: And,
                                                    values: [
                                                        Name(
                                                            ExprName {
                                                                range: 602..603,
                                                                id: "x",
                                                                ctx: Load,
                                                            },
                                                        ),
                                                        Name(
                                                            ExprName {
                                                                range: 608..609,
                                                                id: "y",
                                                                ctx: Load,
                                                            },
                                                        ),
                                                    ],
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 611..623,
                    value: Call(
                        ExprCall {
                            range: 611..623,
                            func: Name(
                                ExprName {
                                    range: 611..615,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 615..623,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 616..622,
                                            value: BinOp(
                                                ExprBinOp {
                                                    range: 617..622,
                                                    left: Name(
                                                        ExprName {
                                                            range: 617..618,
                                                            id: "x",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    op: BitOr,
                                                    right: Name(
                                                        ExprName {
                                                            range: 621..622,
                                                            id: "y",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 624..638,
                    value: Call(
                        ExprCall {
                            range: 624..638,
                            func: Name(
                                ExprName {
                                    range: 624..628,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 628..638,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 629..637,
                                            value: Await(
                                                ExprAwait {
                                                    range: 630..637,
                                                    value: Name(
                                                        ExprName {
                                                            range: 636..637,
                                                            id: "x",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 639..657,
                    value: Call(
                        ExprCall {
                            range: 639..657,
                            func: Name(
                                ExprName {
                                    range: 639..643,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 643..657,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 644..656,
                                            value: Lambda(
                                                ExprLambda {
                                                    range: 645..656,
                                                    parameters: Some(
                                                        Parameters {
                                                            range: 652..653,
                                                            posonlyargs: [],
                                                            args: [
                                                                ParameterWithDefault {
                                                                    range: 652..653,
                                                                    parameter: Parameter {
                                                                        range: 652..653,
                                                                        name: Identifier {
                                                                            id: "x",
                                                                            range: 652..653,
                                                                        },
                                                                        annotation: None,
                                                                    },
                                                                    default: None,
                                                                },
                                                            ],
                                                            vararg: None,
                                                            kwonlyargs: [],
                                                            kwarg: None,
                                                        },
                                                    ),
                                                    body: Name(
                                                        ExprName {
                                                            range: 655..656,
                                                            id: "x",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 658..681,
                    value: Call(
                        ExprCall {
                            range: 658..681,
                            func: Name(
                                ExprName {
                                    range: 658..662,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 662..681,
                                args: [
                                    Starred(
                                        ExprStarred {
                                            range: 663..680,
                                            value: If(
                                                ExprIf {
                                                    range: 664..680,
                                                    test: BooleanLiteral(
                                                        ExprBooleanLiteral {
                                                            range: 669..673,
                                                            value: true,
                                                        },
                                                    ),
                                                    body: Name(
                                                        ExprName {
                                                            range: 664..665,
                                                            id: "x",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    orelse: Name(
                                                        ExprName {
                                                            range: 679..680,
                                                            id: "y",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                },
                                            ),
                                            ctx: Load,
                                        },
                                    ),
                                ],
                                keywords: [],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 700..709,
                    value: Call(
                        ExprCall {
                            range: 700..709,
                            func: Name(
                                ExprName {
                                    range: 700..704,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 704..709,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 705..708,
                                        arg: None,
                                        value: Name(
                                            ExprName {
                                                range: 707..708,
                                                id: "x",
                                                ctx: Load,
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 710..725,
                    value: Call(
                        ExprCall {
                            range: 710..725,
                            func: Name(
                                ExprName {
                                    range: 710..714,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 714..725,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 715..724,
                                        arg: None,
                                        value: BoolOp(
                                            ExprBoolOp {
                                                range: 717..724,
                                                op: And,
                                                values: [
                                                    Name(
                                                        ExprName {
                                                            range: 717..718,
                                                            id: "x",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                    Name(
                                                        ExprName {
                                                            range: 723..724,
                                                            id: "y",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ],
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 726..741,
                    value: Call(
                        ExprCall {
                            range: 726..741,
                            func: Name(
                                ExprName {
                                    range: 726..730,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 730..741,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 731..740,
                                        arg: None,
                                        value: Await(
                                            ExprAwait {
                                                range: 733..740,
                                                value: Name(
                                                    ExprName {
                                                        range: 739..740,
                                                        id: "x",
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 742..766,
                    value: Call(
                        ExprCall {
                            range: 742..766,
                            func: Name(
                                ExprName {
                                    range: 742..746,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 746..766,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 747..765,
                                        arg: None,
                                        value: If(
                                            ExprIf {
                                                range: 749..765,
                                                test: BooleanLiteral(
                                                    ExprBooleanLiteral {
                                                        range: 754..758,
                                                        value: true,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        range: 749..750,
                                                        id: "x",
                                                        ctx: Load,
                                                    },
                                                ),
                                                orelse: Name(
                                                    ExprName {
                                                        range: 764..765,
                                                        id: "y",
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 767..784,
                    value: Call(
                        ExprCall {
                            range: 767..784,
                            func: Name(
                                ExprName {
                                    range: 767..771,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 771..784,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 772..783,
                                        arg: None,
                                        value: Yield(
                                            ExprYield {
                                                range: 775..782,
                                                value: Some(
                                                    Name(
                                                        ExprName {
                                                            range: 781..782,
                                                            id: "x",
                                                            ctx: Load,
                                                        },
                                                    ),
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
            Expr(
                StmtExpr {
                    range: 785..804,
                    value: Call(
                        ExprCall {
                            range: 785..804,
                            func: Name(
                                ExprName {
                                    range: 785..789,
                                    id: "call",
                                    ctx: Load,
                                },
                            ),
                            arguments: Arguments {
                                range: 789..804,
                                args: [],
                                keywords: [
                                    Keyword {
                                        range: 790..803,
                                        arg: None,
                                        value: Lambda(
                                            ExprLambda {
                                                range: 792..803,
                                                parameters: Some(
                                                    Parameters {
                                                        range: 799..800,
                                                        posonlyargs: [],
                                                        args: [
                                                            ParameterWithDefault {
                                                                range: 799..800,
                                                                parameter: Parameter {
                                                                    range: 799..800,
                                                                    name: Identifier {
                                                                        id: "x",
                                                                        range: 799..800,
                                                                    },
                                                                    annotation: None,
                                                                },
                                                                default: None,
                                                            },
                                                        ],
                                                        vararg: None,
                                                        kwonlyargs: [],
                                                        kwarg: None,
                                                    },
                                                ),
                                                body: Name(
                                                    ExprName {
                                                        range: 802..803,
                                                        id: "x",
                                                        ctx: Load,
                                                    },
                                                ),
                                            },
                                        ),
                                    },
                                ],
                            },
                        },
                    ),
                },
            ),
        ],
    },
)
```
