//! returns: 0

/// Retain every supported regional projection slot at once.
fn full 'r (p: &'r u32) -> u32 {
    let refs: [&'r u32; 32] = [&*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p, &*p];
    let mut sum: u32 = 0;
    for item in refs {
        set sum += *item;
    }
    return sum;
}

/// Reuse child-region loans across loop exits and later iterations.
fn recycle() -> u32 {
    let mut value: u32 = 0;
    let outer: 'outer = &mut value in {
        for i in 0..3 {
            let inner: 'inner = &mut *outer in {
                set *inner += 1;
            }
            if i == 1 { continue; }
            let read: 'read = &*outer in {
                assert *read == i + 1;
            }
        }
        loop {
            let inner: 'last = &mut *outer in {
                set *inner += 1;
            }
            break;
        }
        set *outer += 1;
    }
    return value;
}

/// Initialize and unwind every supported nested loop slot.
fn nested() -> u32 {
    let mut value: u32 = 0;
    loop {
        loop {
            loop {
                loop {
                    loop {
                        loop {
                            loop {
                                loop {
                                    loop {
                                        loop {
                                            loop {
                                                loop {
                                                    loop {
                                                        loop {
                                                            loop {
                                                                loop {
                                                                    let p: 'value = &mut value in {
                                                                        set *p = 9;
                                                                    }
                                                                    break;
                                                                }
                                                                break;
                                                            }
                                                            break;
                                                        }
                                                        break;
                                                    }
                                                    break;
                                                }
                                                break;
                                            }
                                            break;
                                        }
                                        break;
                                    }
                                    break;
                                }
                                break;
                            }
                            break;
                        }
                        break;
                    }
                    break;
                }
                break;
            }
            break;
        }
        break;
    }
    return value;
}

/// Execute full and reused loan tables with fresh checker state per function.
@default fn main() -> u32 {
    let value: u32 = 2;
    let p: 'value = &value in {
        assert full(p) == 64;
    }
    assert recycle() == 5;
    assert nested() == 9;
    return 0;
}