// integer values from -2^191 .. 2^191-1
struct Large {
mut:
    l u64
    m u64
    h u64
}

fn (a Large) clone() Large {
    r := Large{
        l: a.l
        m: a.m
        h: a.h
    }
    return r
}

fn (mut a Large) add(b Large) {
    oldl := a.l
    a.l += b.l
    oldm := a.m
    if a.l < oldl {
        a.m++
    }
    a.m += b.m
    if a.m < oldm || (a.l < oldl && a.m <= oldm) {
        a.h++
    }
    a.h += b.h
}

fn doub_large(shared a Large, shared b Large, shared c Large, shared d Large, shared e Large) {
    for _ in 0 .. 50 {
        lock a, b; rlock c, d, e {
            // double the sum by adding all objects to a or b
            old_a := a.clone()
            a.add(b)
            b.add(old_a)
            a.add(c)
            b.add(d)
            a.add(e)
        }
    }
}

fn test_mixed_order_lock_rlock() {
    // initialize objects so that their sum = 1
    shared a := Large{
        l: 4
    }
    shared b := Large{
        l: u64(-7)
        m: u64(-1)
        h: u64(-1)
    }
    shared c := Large{
        l: 17
    }
    shared d := Large{
        l: u64(-11)
        m: u64(-1)
        h: u64(-1)
    }
    shared e := Large{
        l: u64(-2)
        m: u64(-1)
        h: u64(-1)
    }
    // spawn 3 threads for doubling with different orders of objects
    t1 := spawn doub_large(shared a, shared b, shared c, shared d, shared e)
    t2 := spawn doub_large(shared e, shared b, shared a, shared c, shared d)
    t3 := spawn doub_large(shared b, shared a, shared e, shared d, shared c)
    t1.wait()
    t2.wait()
    t3.wait()
    // calculate the sum after 3*50 doublings
    mut sum := Large{}
    rlock a, b, c, d, e {
        sum.add(a)
        sum.add(b)
        sum.add(c)
        sum.add(d)
        sum.add(e)
    }
    // the sum should be 2^150
    assert sum.l == 0
    assert sum.m == 0
    assert sum.h == 4194304
}