#define N 2
#define LENGTH 3
#define R 2

int to_reverse[LENGTH]; // array to reverse
int reversed[LENGTH]; // array where the reverse is stored

// stores termination of each pid
bool done[N]; // initialized to false

// ThreadedReverser implementation
proctype ThreadedReverser(int from; int to; int n) {
    printf("proc[%d]: started\n", _pid);
    
    int k;
    for (k: from .. to) {
        printf("reversed[%d] = to_reverse[%d]\n", LENGTH - k - 1, k);
        reversed[LENGTH - k - 1] = to_reverse[k];
    }

    printf("proc[%d]: ended\n", n);
    done[n] = true;
}

init {
    printf("program start\n");
    // array initialization
    {
        int i;
        for (i in to_reverse) {
            int value;
            select(value: 0 .. R);
            to_reverse[i] = value;
            printf("to_reverse[%d]: %d\n", i, value);
        }
    }

    // ParallelReverser implementation
    int n;
    int s = LENGTH / N;
    
    // fork section
    for (n: 0 .. (N - 1)) {
        int from = n * s;
        int to;
        if
        :: (n == N - 1) -> to = LENGTH - 1;
        :: else -> to = n * s + s - 1; 
        fi
        run ThreadedReverser(from, to, n);
    }

    // join section
    for (n: 0 .. (N - 1)) {
        (done[n] == true);
        printf("init: joined process %d\n", n);
    }

    printf("program end\n");
}

// ltl syntax: https://spinroot.com/spin/Man/ltl.html
ltl test {
    (done[N - 1] == false) U (reversed[LENGTH - 1] == to_reverse[0])
}