/// Active binding slots below `len` must contain metadata.

    /// Initialized slots for resolved binding metadata.

    symbols: [?TrackedSymbol; MAX_LINEAR_BINDINGS],

    /// Number of active binding slots in `symbols`.

/// Create an empty ownership environment with initialized binding slots.

fn linearEnv() -> LinearEnv {

    return LinearEnv {

        regionalLoans: 0,

        symbols: [nil; MAX_LINEAR_BINDINGS],

        available: 0,

        len: 0,

        terminated: false,

    };

}

/// Read initialized binding metadata from the active prefix.

fn linearSymbol(env: &LinearEnv, index: u32) -> TrackedSymbol {

    assert index < env.len, "linearSymbol: binding index outside active prefix";

    let symbol = env.symbols[index] else panic "linearSymbol: missing active binding";

    return symbol;

}

        if linearSymbol(env, i).id == symbolId {

                let sym = linearSymbol(env, i);

        let sym = linearSymbol(env, index);

            let sym = linearSymbol(left, i);

            let sym = linearSymbol(env, i);

            let sym = linearSymbol(env, i);

                let sym = linearSymbol(env, i);

                let sym = linearSymbol(&branch, i);

        let mut env = linearEnv();

/// Reused ownership slots retain the current binding's exact-use diagnostics.

@test unsafe fn testLinearScratchSlotReuse() throws (testing::TestError) {

    let mut arena = testArena();

    let storage: 'test = &mut arena in {

        let mut res = testResolver(storage);

        let result = try resolveProgramStr(&mut res,

            "union Token: Once { Value(u32) } fn consume(t: Token) { match t { case Token::Value(_) => {} } } fn f() { { let first = Token::Value(1); consume(first); } let second = Token::Value(2); consume(second); consume(second); }"

        );

        try expectErrorKind(&result, super::ErrorKind::LinearUseAfterConsume("second"));

    }

    let mut branchArena = testArena();

    let branchStorage: 'branch = &mut branchArena in {

        let mut res = testResolver(branchStorage);

        let result = try resolveProgramStr(&mut res,

            "union Token: Once { Value(u32) } fn consume(t: Token) { match t { case Token::Value(_) => {} } } fn f(choice: bool) { { let first = Token::Value(1); consume(first); } let second = Token::Value(2); if choice { consume(second); } }"

        );

        try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("second"));

    }

}

//! returns: 0

/// Exact-use token retained in ownership-checker scratch slots.

union Token: Once {

    /// Token payload.

    Value(u32),

}

/// Consume a token and return its payload.

fn consume(token: Token) -> u32 {

    match token {

        case Token::Value(value) => return value,

    }

}

/// Fill every tracking slot, copy branch state, and reuse slots after scope exit.

fn exercise(choice: bool) -> u32 {

    let mut sum: u32 = 0;

    {

        let t0 = Token::Value(0);

        let t1 = Token::Value(1);

        let t2 = Token::Value(2);

        let t3 = Token::Value(3);

        let t4 = Token::Value(4);

        let t5 = Token::Value(5);

        let t6 = Token::Value(6);

        let t7 = Token::Value(7);

        let t8 = Token::Value(8);

        let t9 = Token::Value(9);

        let t10 = Token::Value(10);

        let t11 = Token::Value(11);

        let t12 = Token::Value(12);

        let t13 = Token::Value(13);

        let t14 = Token::Value(14);

        let t15 = Token::Value(15);

        let t16 = Token::Value(16);

        let t17 = Token::Value(17);

        let t18 = Token::Value(18);

        let t19 = Token::Value(19);

        let t20 = Token::Value(20);

        let t21 = Token::Value(21);

        let t22 = Token::Value(22);

        let t23 = Token::Value(23);

        let t24 = Token::Value(24);

        let t25 = Token::Value(25);

        let t26 = Token::Value(26);

        let t27 = Token::Value(27);

        let t28 = Token::Value(28);

        let t29 = Token::Value(29);

        let t30 = Token::Value(30);

        let t31 = Token::Value(31);

        if choice {

            set sum += consume(t0);

        } else {

            set sum += consume(t0);

        }

        set sum += consume(t1);

        set sum += consume(t2);

        set sum += consume(t3);

        set sum += consume(t4);

        set sum += consume(t5);

        set sum += consume(t6);

        set sum += consume(t7);

        set sum += consume(t8);

        set sum += consume(t9);

        set sum += consume(t10);

        set sum += consume(t11);

        set sum += consume(t12);

        set sum += consume(t13);

        set sum += consume(t14);

        set sum += consume(t15);

        set sum += consume(t16);

        set sum += consume(t17);

        set sum += consume(t18);

        set sum += consume(t19);

        set sum += consume(t20);

        set sum += consume(t21);

        set sum += consume(t22);

        set sum += consume(t23);

        set sum += consume(t24);

        set sum += consume(t25);

        set sum += consume(t26);

        set sum += consume(t27);

        set sum += consume(t28);

        set sum += consume(t29);

        set sum += consume(t30);

        set sum += consume(t31);

    }

    for i in 0..3 {

        let token = Token::Value(i);

        if i == 1 {

            set sum += consume(token);

            continue;

        }

        set sum += consume(token);

    }

    let last = Token::Value(1);

    set sum += consume(last);

    return sum;

}

/// Execute both branch paths and verify all token payloads.

@default fn main() -> u32 {

    assert exercise(true) == 500;

    assert exercise(false) == 500;

    return 0;

}