G-single-item-realtime #0
Let:
  T1 = {:index 30420, :time 63438493635, :type :ok, :process 7, :f :txn, :value [[:r 454 nil]]}
  T2 = {:index 30296, :time 63233892403, :type :ok, :process 4, :f :txn, :value [[:r 451 [1 3 10 9 5 6 26 13 14 29 32 37 31 41 40 48 49 61 65 66]] [:append 454 5]]}
  T3 = {:index 30306, :time 63252259796, :type :ok, :process 5, :f :txn, :value [[:append 451 69]]}
  T4 = {:index 30354, :time 63362358751, :type :ok, :process 9, :f :txn, :value [[:r 444 [2 3 5 6 7 9 11 13 15 20 22 29 30 38 39 40 32 37 45 47 59 55 56 67 72 75 83 85 89 88 90 91 92 96 98 104 99 101 113 114 118 116 124 128 133 138 144 158 159 160 156 171 174 183 187 190 192 194 198 203 205 219 225 234]] [:r 451 [1 3 10 9 5 6 26 13 14 29 32 37 31 41 40 48 49 61 65 66 67 69]]]}
  T5 = {:index 30404, :time 63421631805, :type :ok, :process 8, :f :txn, :value [[:r 456 [1 2 3 4 5]] [:append 454 12] [:r 456 [1 2 3 4 5]] [:append 451 81]]}
  T6 = {:index 30406, :time 63421775207, :type :ok, :process 8, :f :txn, :value [[:r 248 [2 4 10 13 14 15 16 18 23 28 33 34 38 40 42 51 53 65 66 67 68 72 76 79 80 82 87 88 89 90 92 94 95]]]}
  T7 = {:index 30408, :time 63424993287, :type :ok, :process 8, :f :txn, :value [[:r 456 nil]]}
  T8 = {:index 30416, :time 63437155835, :type :ok, :process 0, :f :txn, :value [[:append 460 1] [:append 460 2]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 454, which T2 created by appending 5.
  - T2 < T3, because T2 completed at index 30296, 0.014 seconds before the invocation of T3, at index 30301.
  - T3 < T4, because T4 observed T3's append of 69 to key 451.
  - T4 < T5, because T4 completed at index 30354, 0.004 seconds before the invocation of T5, at index 30361.
  - T5 < T6, because T5 completed at index 30404, 0.000 seconds before the invocation of T6, at index 30405.
  - T6 < T7, because T6 completed at index 30406, 0.000 seconds before the invocation of T7, at index 30407.
  - T7 < T8, because T7 completed at index 30408, 0.004 seconds before the invocation of T8, at index 30411.
  - However, T8 < T1, because T8 completed at index 30416, 0.000 seconds before the invocation of T1, at index 30419: a contradiction!


G-single-item-realtime #1
Let:
  T1 = {:index 15998, :time 34192222461, :type :ok, :process 3, :f :txn, :value [[:append 274 2] [:r 272 [10 11 19 20 26 28 22 35 36 38]]]}
  T2 = {:index 16012, :time 34213775943, :type :ok, :process 0, :f :txn, :value [[:append 267 54] [:r 261 [2 6 8 10 15 16 17 21 22 23 26 28 32 31 34]]]}
  T3 = {:index 16032, :time 34247832692, :type :ok, :process 7, :f :txn, :value [[:append 261 36] [:append 267 55] [:r 0 [3 6]]]}
  T4 = {:index 16040, :time 34259668535, :type :ok, :process 0, :f :txn, :value [[:append 248 10]]}
  T5 = {:index 16774, :time 35778723457, :type :ok, :process 8, :f :txn, :value [[:append 248 13]]}
  T6 = {:index 16892, :time 36062062036, :type :ok, :process 1, :f :txn, :value [[:append 248 14]]}
  T7 = {:index 17078, :time 36452828313, :type :ok, :process 5, :f :txn, :value [[:r 288 [3 11]] [:r 288 [3 11]] [:append 248 15]]}
  T8 = {:index 17082, :time 36457472152, :type :ok, :process 2, :f :txn, :value [[:r 274 nil]]}

Then:
  - T1 < T2, because T1 completed at index 15998, 0.019 seconds before the invocation of T2, at index 16011.
  - T2 < T3, because T3 appended 55 after T2 appended 54 to 267.
  - T3 < T4, because T3 completed at index 16032, 0.012 seconds before the invocation of T4, at index 16039.
  - T4 < T5, because T5 appended 13 after T4 appended 10 to 248.
  - T5 < T6, because T6 appended 14 after T5 appended 13 to 248.
  - T6 < T7, because T7 appended 15 after T6 appended 14 to 248.
  - T7 < T8, because T7 completed at index 17078, 0.003 seconds before the invocation of T8, at index 17081.
  - However, T8 < T1, because T8 observed the initial (nil) state of 274, which T1 created by appending 2: a contradiction!


G-single-item-realtime #2
Let:
  T1 = {:index 37532, :time 77649875244, :type :ok, :process 2, :f :txn, :value [[:r 554 nil]]}
  T2 = {:index 37518, :time 77627735972, :type :ok, :process 0, :f :txn, :value [[:r 553 [4]] [:append 554 2] [:append 554 3]]}
  T3 = {:index 37524, :time 77637334514, :type :ok, :process 4, :f :txn, :value [[:append 343 159]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 554, which T2 created by appending 2.
  - T2 < T3, because T2 completed at index 37518, 0.002 seconds before the invocation of T3, at index 37521.
  - However, T3 < T1, because T3 completed at index 37524, 0.001 seconds before the invocation of T1, at index 37527: a contradiction!


G-single-item-realtime #3
Let:
  T1 = {:index 43516, :time 89800424718, :type :ok, :process 1, :f :txn, :value [[:r 635 nil]]}
  T2 = {:index 43335, :time 89395415137, :type :ok, :process 3, :f :txn, :value [[:append 635 1] [:r 635 [1]]]}
  T3 = {:index 43358, :time 89449556393, :type :ok, :process 0, :f :txn, :value [[:append 635 9] [:append 634 6] [:r 635 [1 9]] [:r 631 nil]]}
  T4 = {:index 43368, :time 89462815898, :type :ok, :process 2, :f :txn, :value [[:r 499 [3 5 6 16 18 19 26 30 32 34 38 40 41 42 43 44 47 49 52 53 59 58 62 67 71 72 74 76 78 79 85 88 90 94 101 102 105 107 109 115 117 118 122 124 125 126 130 136 139 140 143 144 145 146 148 149 154 156 157 158 164 165 167 168 173 175 177]] [:append 634 8]]}
  T5 = {:index 43390, :time 89523808576, :type :ok, :process 2, :f :txn, :value [[:append 635 16] [:r 634 [6 8]] [:append 634 9] [:append 636 5]]}
  T6 = {:index 43428, :time 89612766134, :type :ok, :process 2, :f :txn, :value [[:append 636 11]]}
  T7 = {:index 43456, :time 89668743412, :type :ok, :process 9, :f :txn, :value [[:append 636 9]]}
  T8 = {:index 43508, :time 89786637941, :type :ok, :process 5, :f :txn, :value [[:r 634 [6 8 9 14 16 21 23 33]] [:append 636 12]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 635, which T2 created by appending 1.
  - T2 < T3, because T3 appended 9 after T2 appended 1 to 635.
  - T3 < T4, because T4 appended 8 after T3 appended 6 to 634.
  - T4 < T5, because T5 appended 9 after T4 appended 8 to 634.
  - T5 < T6, because T6 appended 11 after T5 appended 5 to 636.
  - T6 < T7, because T7 appended 9 after T6 appended 11 to 636.
  - T7 < T8, because T8 appended 12 after T7 appended 9 to 636.
  - However, T8 < T1, because T8 completed at index 43508, 0.013 seconds before the invocation of T1, at index 43515: a contradiction!


G-single-item-realtime #4
Let:
  T1 = {:index 41528, :time 85683897489, :type :ok, :process 3, :f :txn, :value [[:r 608 nil]]}
  T2 = {:index 41476, :time 85549549147, :type :ok, :process 3, :f :txn, :value [[:append 608 2]]}
  T3 = {:index 41496, :time 85642747465, :type :ok, :process 3, :f :txn, :value [[:r 596 [4 5 10 11 12 23 25 27 28 35 29 37 47 52 54 55 60 57 63 68 70 75 79 88 94 95 99 100 101 98 108 109 105 104 116 120 119 117 118 131 133 132 136 141 140 145 147 155 162 163 170 173 174 180 185 190 193 201 202 204 205 211 231 230 243]] [:append 608 3] [:append 608 4]]}
  T4 = {:index 41522, :time 85673559419, :type :ok, :process 3, :f :txn, :value [[:append 608 18] [:append 248 164] [:r 604 [3 10 11 17 23 26 27 28]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 608, which T2 created by appending 2.
  - T2 < T3, because T2 completed at index 41476, 0.000 seconds before the invocation of T3, at index 41477.
  - T3 < T4, because T4 appended 18 after T3 appended 4 to 608.
  - However, T4 < T1, because T4 completed at index 41522, 0.000 seconds before the invocation of T1, at index 41523: a contradiction!


G-single-item-realtime #5
Let:
  T1 = {:index 40662, :time 83828669133, :type :ok, :process 6, :f :txn, :value [[:r 602 nil]]}
  T2 = {:index 40618, :time 83735817875, :type :ok, :process 4, :f :txn, :value [[:r 581 [2 5 6 10 15 19 20 21 26 32 33 38 43 41 48 55 54 58 61 69 71 73 74 77 78 79]] [:append 602 1]]}
  T3 = {:index 40620, :time 83735958403, :type :ok, :process 4, :f :txn, :value [[:r 602 nil]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 602, which T2 created by appending 1.
  - T2 < T3, because T2 completed at index 40618, 0.000 seconds before the invocation of T3, at index 40619.
  - However, T3 < T1, because T3 completed at index 40620, 0.008 seconds before the invocation of T1, at index 40625: a contradiction!


G-single-item-realtime #6
Let:
  T1 = {:index 40426, :time 83413964931, :type :ok, :process 2, :f :txn, :value [[:r 600 nil]]}
  T2 = {:index 40376, :time 83321395248, :type :ok, :process 2, :f :txn, :value [[:append 600 4] [:r 600 [4]]]}
  T3 = {:index 40408, :time 83394384800, :type :ok, :process 2, :f :txn, :value [[:r 598 [2 6 8 9 18 24 26]] [:append 499 125] [:append 600 22] [:r 600 [4 22]]]}
  T4 = {:index 40424, :time 83413719193, :type :ok, :process 2, :f :txn, :value [[:append 600 24] [:r 596 [4 5 10 11 12 23 25 27 28 35 29 37 47 52 54 55 60 57 63]] [:append 600 25] [:r 596 [4 5 10 11 12 23 25 27 28 35 29 37 47 52 54 55 60 57 63]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 600, which T2 created by appending 4.
  - T2 < T3, because T3 appended 22 after T2 appended 4 to 600.
  - T3 < T4, because T4 appended 24 after T3 appended 22 to 600.
  - However, T4 < T1, because T4 completed at index 40424, 0.000 seconds before the invocation of T1, at index 40425: a contradiction!


G-single-item-realtime #7
Let:
  T1 = {:index 42728, :time 88195097625, :type :ok, :process 0, :f :txn, :value [[:r 625 nil]]}
  T2 = {:index 42492, :time 87653147717, :type :ok, :process 4, :f :txn, :value [[:append 611 44] [:append 625 2] [:append 621 186]]}
  T3 = {:index 42514, :time 87698541049, :type :ok, :process 2, :f :txn, :value [[:append 621 194] [:r 621 [9 10 8 17 30 31 35 38 40 44 52 56 59 64 66 67 68 70 75 77 76 88 87 104 101 107 103 128 129 130 126 119 120 121 133 134 138 146 162 166 171 182 185 169 186 194]] [:append 625 6]]}
  T4 = {:index 42574, :time 87844143203, :type :ok, :process 7, :f :txn, :value [[:append 625 16] [:append 611 47]]}
  T5 = {:index 42682, :time 88094369190, :type :ok, :process 7, :f :txn, :value [[:append 626 3] [:r 626 [3]] [:r 611 [2 6 8 9 11 14 16 19 23 32 36 38 39 43 44 45 47]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 625, which T2 created by appending 2.
  - T2 < T3, because T3 appended 194 after T2 appended 186 to 621.
  - T3 < T4, because T4 appended 16 after T3 appended 6 to 625.
  - T4 < T5, because T5 observed T4's append of 47 to key 611.
  - However, T5 < T1, because T5 completed at index 42682, 0.027 seconds before the invocation of T1, at index 42697: a contradiction!


G-single-item-realtime #8
Let:
  T1 = {:index 25182, :time 52767296373, :type :ok, :process 8, :f :txn, :value [[:append 398 8]]}
  T2 = {:index 25190, :time 52778841294, :type :ok, :process 2, :f :txn, :value [[:r 398 nil]]}

Then:
  - T1 < T2, because T1 completed at index 25182, 0.001 seconds before the invocation of T2, at index 25185.
  - However, T2 < T1, because T2 observed the initial (nil) state of 398, which T1 created by appending 8: a contradiction!


G-single-item-realtime #9
Let:
  T1 = {:index 43672, :time 90119285194, :type :ok, :process 1, :f :txn, :value [[:r 641 nil]]}
  T2 = {:index 43630, :time 90037826114, :type :ok, :process 2, :f :txn, :value [[:append 641 4] [:r 641 [4]] [:r 637 [1 4]]]}
  T3 = {:index 43664, :time 90097348605, :type :ok, :process 4, :f :txn, :value [[:r 641 [4]] [:r 641 [4]] [:r 638 [3 13 14]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 641, which T2 created by appending 4.
  - T2 < T3, because T3 observed T2's append of 4 to key 641.
  - However, T3 < T1, because T3 completed at index 43664, 0.022 seconds before the invocation of T1, at index 43671: a contradiction!


G-single-item-realtime #10
Let:
  T1 = {:index 41548, :time 85707924273, :type :ok, :process 5, :f :txn, :value [[:r 610 nil]]}
  T2 = {:index 41544, :time 85706466042, :type :ok, :process 5, :f :txn, :value [[:append 610 4] [:append 610 5] [:r 581 [2 5 6 10 15 19 20 21 26 32 33 38 43 41 48 55 54 58 61 69 71 73 74 77 78 79 83 89 90 96 101 102 104 111 114 118 124]]]}
  T3 = {:index 41546, :time 85707798249, :type :ok, :process 5, :f :txn, :value [[:append 610 7]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 610, which T2 created by appending 4.
  - T2 < T3, because T3 appended 7 after T2 appended 5 to 610.
  - However, T3 < T1, because T3 completed at index 41546, 0.000 seconds before the invocation of T1, at index 41547: a contradiction!


G-single-item-realtime #11
Let:
  T1 = {:index 38550, :time 79555187480, :type :ok, :process 2, :f :txn, :value [[:r 570 nil]]}
  T2 = {:index 38498, :time 79453762726, :type :ok, :process 2, :f :txn, :value [[:append 570 7]]}
  T3 = {:index 38520, :time 79490819330, :type :ok, :process 8, :f :txn, :value [[:append 571 17] [:r 547 [2 5 6 7 8 9 15 18 23 28 34 37 39 40 46 47]] [:r 571 [1 4 7 17]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 570, which T2 created by appending 7.
  - T2 < T3, because T2 completed at index 38498, 0.030 seconds before the invocation of T3, at index 38515.
  - However, T3 < T1, because T3 completed at index 38520, 0.019 seconds before the invocation of T1, at index 38529: a contradiction!


G-single-item-realtime #12
Let:
  T1 = {:index 37420, :time 77398726898, :type :ok, :process 1, :f :txn, :value [[:r 549 nil]]}
  T2 = {:index 37406, :time 77376299870, :type :ok, :process 7, :f :txn, :value [[:append 549 7] [:append 541 71]]}
  T3 = {:index 37414, :time 77388138242, :type :ok, :process 9, :f :txn, :value [[:r 550 [2]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 549, which T2 created by appending 7.
  - T2 < T3, because T2 completed at index 37406, 0.012 seconds before the invocation of T3, at index 37413.
  - However, T3 < T1, because T3 completed at index 37414, 0.010 seconds before the invocation of T1, at index 37419: a contradiction!


G-single-item-realtime #13
Let:
  T1 = {:index 58762, :time 121051452268, :type :ok, :process 4, :f :txn, :value [[:r 867 nil]]}
  T2 = {:index 58730, :time 120988163860, :type :ok, :process 4, :f :txn, :value [[:append 866 7] [:append 867 1] [:r 867 [1]] [:r 867 [1]]]}
  T3 = {:index 58736, :time 121017117914, :type :ok, :process 1, :f :txn, :value [[:r 866 [5 7]] [:append 866 11]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 867, which T2 created by appending 1.
  - T2 < T3, because T3 appended 11 after T2 appended 7 to 866.
  - However, T3 < T1, because T3 completed at index 58736, 0.018 seconds before the invocation of T1, at index 58753: a contradiction!


G-single-item-realtime #14
Let:
  T1 = {:index 41406, :time 85423574243, :type :ok, :process 7, :f :txn, :value [[:r 606 nil]]}
  T2 = {:index 41326, :time 85237460184, :type :ok, :process 9, :f :txn, :value [[:append 606 2] [:r 581 [2 5 6 10 15 19 20 21 26 32 33 38 43 41 48 55 54 58 61 69 71 73 74 77 78 79 83 89 90 96 101 102 104]]]}
  T3 = {:index 41346, :time 85289770281, :type :ok, :process 4, :f :txn, :value [[:append 606 6] [:append 606 7]]}
  T4 = {:index 41356, :time 85311993627, :type :ok, :process 6, :f :txn, :value [[:r 596 [4 5 10 11 12 23 25 27 28 35 29 37 47 52 54 55 60 57 63 68 70 75 79 88 94 95 99 100 101 98 108 109 105 104 116 120 119 117 118 131 133 132 136 141 140 145 147 155 162 163 170 173 174 180 185 190 193 201 202 204 205 211]]]}
  T5 = {:index 41384, :time 85370964601, :type :ok, :process 5, :f :txn, :value [[:r 604 [3 10 11 17]] [:append 596 230] [:append 604 23]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 606, which T2 created by appending 2.
  - T2 < T3, because T3 appended 6 after T2 appended 2 to 606.
  - T3 < T4, because T3 completed at index 41346, 0.021 seconds before the invocation of T4, at index 41355.
  - T4 < T5, because T4 completed at index 41356, 0.000 seconds before the invocation of T5, at index 41359.
  - However, T5 < T1, because T5 completed at index 41384, 0.014 seconds before the invocation of T1, at index 41387: a contradiction!


G-single-item-realtime #15
Let:
  T1 = {:index 44274, :time 91270478404, :type :ok, :process 7, :f :txn, :value [[:r 644 nil]]}
  T2 = {:index 44174, :time 91081932253, :type :ok, :process 7, :f :txn, :value [[:append 644 3]]}
  T3 = {:index 44184, :time 91094022963, :type :ok, :process 1, :f :txn, :value [[:r 617 [2 4 7 8 9 10 14 17 18 19 22 28]] [:r 638 [3 13 14 18 20 24 27 30 31 32 35 38 44 45 49 54 47 59 60 67 71 72 81 82 86]] [:r 638 [3 13 14 18 20 24 27 30 31 32 35 38 44 45 49 54 47 59 60 67 71 72 81 82 86]]]}
  T4 = {:index 44214, :time 91148933762, :type :ok, :process 1, :f :txn, :value [[:r 642 [1 5 8 9 10 11 13 16 22 27 29 31 37 39]] [:r 499 [3 5 6 16 18 19 26 30 32 34 38 40 41 42 43 44 47 49 52 53 59 58 62 67 71 72 74 76 78 79 85 88 90 94 101 102 105 107 109 115 117 118 122 124 125 126 130 136 139 140 143 144 145 146 148 149 154 156 157 158 164 165 167 168 173 175 177 179]] [:r 642 [1 5 8 9 10 11 13 16 22 27 29 31 37 39]]]}
  T5 = {:index 44268, :time 91255711072, :type :ok, :process 1, :f :txn, :value [[:r 631 [3 5 7 13 15 17 20 24 27 34 36 42]] [:r 638 [3 13 14 18 20 24 27 30 31 32 35 38 44 45 49 54 47 59 60 67 71 72 81 82 86 92 109]] [:r 644 [3 4 2 1 13]] [:r 644 [3 4 2 1 13]]]}

Then:
  - T1 < T2, because T1 observed the initial (nil) state of 644, which T2 created by appending 3.
  - T2 < T3, because T2 completed at index 44174, 0.002 seconds before the invocation of T3, at index 44181.
  - T3 < T4, because T3 completed at index 44184, 0.000 seconds before the invocation of T4, at index 44185.
  - T4 < T5, because T4 completed at index 44214, 0.000 seconds before the invocation of T5, at index 44215.
  - However, T5 < T1, because T5 completed at index 44268, 0.014 seconds before the invocation of T1, at index 44273: a contradiction!