Add an SSI regression test that tests all interesting permutations in the

order of begin, prepare, and commit of three concurrent transactions that
have conflicts between them.

The test runs for a quite long time, and the expected output file is huge,
but this test caught some serious bugs during development, so seems
worthwhile to keep. The test uses prepared transactions, so it fails if the
server has max_prepared_transactions=0. Because of that, it's marked as
"ignore" in the schedule file.

Dan Ports

4 files changed, 36365 insertions, 2 deletions

diff --git a/src/test/isolation/expected/prepared-transactions.out b/src/test/isolation/expected/prepared-transactions.out
new file mode 100644
index 0000000000..fa672f1cb0
--- /dev/null
+++ b/src/test/isolation/expected/prepared-transactions.out
@@ -0,0 +1,34843 @@
+Parsed test spec with 4 sessions
+
+starting permutation: r1 r2 w2 w3 p1 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p1 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p1 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p1 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p1 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p1 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p1 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p2 p1 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p2 p1 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p2 p3 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p2 p3 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p2 p3 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p2 p3 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p2 p3 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 w3 p3 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 w3 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 w3 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 w3 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 w3 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 w3 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 w3 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 w3 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 p2 w3 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p1 p2 w3 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 w3 p1 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 w3 p1 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 w3 p3 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 w3 p3 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 w3 p3 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 w3 p3 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 w3 p3 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 p1 w3 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 w2 p2 p1 w3 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 w3 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 w3 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 w3 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 w3 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 w3 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 w3 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 w3 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 p2 w3 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 r2 p1 w2 p2 w3 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p1 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p1 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p1 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p1 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p1 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p1 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p1 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p2 p1 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p2 p1 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p2 p3 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p2 p3 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p2 p3 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p2 p3 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p2 p3 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 r2 p3 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 r2 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 r2 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 r2 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 r2 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 r2 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 r2 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 r2 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 r2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 r2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 r2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 r2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 r2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 c3 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 c3 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 c3 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p1 p3 c3 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 r2 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 r2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 r2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 r2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 r2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 r2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 c3 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 c3 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 c3 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 p1 c3 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 r2 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 r2 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 r2 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 r2 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 r2 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 r2 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 p1 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 p1 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 p1 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 w3 p3 c3 p1 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 r2 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 r2 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 r2 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 r2 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 r2 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 r2 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 r2 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 r2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 r2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 r2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 r2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 r2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 c3 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 c3 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 c3 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w2 p1 w3 p3 c3 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p1 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p1 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p1 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p1 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p1 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p1 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p1 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p2 p1 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p2 p1 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p2 p3 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p2 p3 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p2 p3 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p2 p3 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p2 p3 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 w2 p3 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 w2 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 w2 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 w2 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 w2 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 w2 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 w2 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 w2 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 w2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 w2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 w2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 w2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 w2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 c3 w2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 c3 w2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 c3 w2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p1 p3 c3 c1 w2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 w2 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 w2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 w2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 w2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 w2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 w2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 c3 w2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 c3 w2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 c3 w2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 p1 c3 c1 w2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 w2 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 w2 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 w2 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 w2 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 w2 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 w2 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 p1 w2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 p1 w2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 p1 w2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 r2 p3 c3 p1 c1 w2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p1 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p1 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p1 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p1 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p1 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p1 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p1 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p2 p1 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p2 p1 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p2 p3 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p2 p3 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p2 p3 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p2 p3 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p2 p3 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 r2 p3 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 r2 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 r2 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 r2 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 r2 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 r2 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 r2 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 r2 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 r2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 r2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 r2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 r2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 r2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 c3 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 c3 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 c3 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p1 p3 c3 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 r2 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 r2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 r2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 r2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 r2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 r2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 c3 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 c3 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 c3 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 p1 c3 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 r2 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 r2 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 r2 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 r2 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 r2 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 r2 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 p1 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 p1 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 p1 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 w2 p3 c3 p1 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 w2 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 w2 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 w2 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 w2 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 w2 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 w2 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 w2 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 w2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 w2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 w2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 w2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 w2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 c3 w2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 c3 w2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 c3 w2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 r2 p3 c3 c1 w2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 r2 p2 p3 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 r2 p2 p3 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p2: PREPARE TRANSACTION 's2';
+step p3: PREPARE TRANSACTION 's3';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+ERROR:  prepared transaction with identifier "s3" does not exist
+step c2: COMMIT PREPARED 's2';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 r2 p3 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 r2 p3 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 r2 p3 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 r2 p3 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 r2 p3 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+c              
+
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 r2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 r2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 r2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 r2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 r2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 c3 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 c3 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 c3 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 w2 p3 c3 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 w2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 w2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 w2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 w2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 w2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 c3 w2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 c3 w2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 c3 w2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 r2 c3 c1 w2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 r2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 r2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 r2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 r2 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 r2 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 c3 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 c3 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 c3 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 w2 c3 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 r2 w2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 r2 w2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 r2 w2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 r2 c1 w2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step c1: COMMIT PREPARED 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 w2 r2 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 w2 r2 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 w2 r2 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 w2 c1 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step w2: INSERT INTO test2 VALUES (2);
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 c1 r2 w2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p1 p3 c3 c1 w2 r2 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p1: PREPARE TRANSACTION 's1';
+step p3: PREPARE TRANSACTION 's3';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step w2: INSERT INTO test2 VALUES (2);
+step r2: SELECT * FROM test3;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p1 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p1 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p1 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p1 c3 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p1 c3 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p2 p1 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p2 p1 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p2 c3 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p2 c3 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 p2 c3 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 c3 p1 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 c3 p1 p2 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 c3 p1 c1 p2 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 c3 p2 p1 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 c3 p2 p1 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step p1: PREPARE TRANSACTION 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 w2 c3 p2 c2 p1 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step p1: PREPARE TRANSACTION 's1';
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 p1 w2 p2 c3 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c1: COMMIT PREPARED 's1';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 p1 w2 p2 c3 c2 c1 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step p2: PREPARE TRANSACTION 's2';
+step c3: COMMIT PREPARED 's3';
+step c2: COMMIT PREPARED 's2';
+ERROR:  prepared transaction with identifier "s2" does not exist
+step c1: COMMIT PREPARED 's1';
+step check: SELECT * FROM test1,test2,test3;
+a              b              c              
+
+
+starting permutation: r1 w3 p3 r2 p1 w2 c3 p2 c1 c2 check
+a              
+
+a              
+
+step r1: SELECT * FROM test2;
+b              
+
+step w3: INSERT INTO test3 VALUES (3);
+step p3: PREPARE TRANSACTION 's3';
+step r2: SELECT * FROM test3;
+c              
+
+step p1: PREPARE TRANSACTION 's1';
+step w2: INSERT INTO test2 VALUES (2);
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c3: COMMIT PREPARED 's3';
+step p2: PREPARE TRANSACTION 's2';
+step c1: COMMIT PREPARED 's1';