//! returns: 0

/// Two independently writable values.
record Pair: Copy {
    /// First value.
    left: u32,
    /// Second value.
    right: u32,
}

/// Inline storage for nested borrows and borrowed slices.
record Storage: Copy {
    /// Nested scalar fields.
    pair: Pair,
    /// First byte buffer.
    first: [u8; 2],
    /// Second byte buffer.
    second: [u8; 2],
}

/// Change two distinct scalar locations.
fn change(left: &mut u32, right: &mut u32) {
    set *left += 3;
    set *right += 5;
}

/// Copy a byte between separate buffers.
fn copy(first: &mut [u8], second: &[u8]) {
    set first[0] = second[1];
}

/// Add a scalar read from a separate field.
fn add(target: &mut u32, value: u32) {
    set *target += value;
}

/// Exercise lexical references and disjoint fields in generated code.
@default fn main() -> i32 {
    let mut data = Storage {
        pair: Pair { left: 1, right: 2 }, first: [0, 0], second: [7, 9],
    };
    change(&mut data.pair.left, &mut data.pair.right);
    add(&mut data.pair.left, data.pair.right);
    {
        let pair: &mut Pair = &mut data.pair;
        let left = &mut pair.left;
        let right = &mut pair.right;
        change(left, right);
        {
            let child = &mut *left;
            set *child += 1;
        }
        set *left += 2;
    }
    {
        let first = &mut data.first[..];
        let second: &[u8] = &data.second[..];
        copy(first, second);
    }
    if data.pair.left <> 17 or data.pair.right <> 12 or data.first[0] <> 9 {
        return 1;
    }
    for i in 0..3 {
        let value = &mut data.pair.left;
        set *value += i;
    }
    if data.pair.left <> 20 {
        return 2;
    }
    let view = &data.pair;
    let alias = view;
    if view.left <> alias.left {
        return 3;
    }
    return 0;
}