diff --git a/AUTHORS b/AUTHORS deleted file mode 100644 --- a/AUTHORS +++ /dev/null @@ -1,7 +0,0 @@ -Donnie Jones -Simon Marlow -Paul Bone , -Duncan Coutts , -Mischa Dieterle , -Thomas Horstmeyer , -Jost Berthold diff --git a/GHC/RTS/EventLogFormat.h b/GHC/RTS/EventLogFormat.h --- a/GHC/RTS/EventLogFormat.h +++ b/GHC/RTS/EventLogFormat.h @@ -1,18 +1,18 @@ /* ----------------------------------------------------------------------------- * - * (c) The GHC Team, 2008-2009 + * (c) The GHC Team, 2008-2012 * * Event log format - * + * * The log format is designed to be extensible: old tools should be * able to parse (but not necessarily understand all of) new versions * of the format, and new tools will be able to understand old log * files. - * + * * Each event has a specific format. If you add new events, give them * new numbers: we never re-use old event numbers. * - * - The format is endian-independent: all values are represented in + * - The format is endian-independent: all values are represented in * bigendian order. * * - The format is extensible: @@ -51,7 +51,7 @@ * Word8* -- extra info (for future extensions) * EVENT_ET_END * - * Event : + * Event : * Word16 -- event_type * Word64 -- time (nanosecs) * [Word16] -- length of the rest (for variable-sized events only) @@ -104,8 +104,7 @@ #define EVENT_STOP_THREAD 2 /* (thread, status, blockinfo) */ #define EVENT_THREAD_RUNNABLE 3 /* (thread) */ #define EVENT_MIGRATE_THREAD 4 /* (thread, new_cap) */ -/* 5, 6 deprecated */ -#define EVENT_SHUTDOWN 7 /* () */ +/* 5, 6, 7 deprecated */ #define EVENT_THREAD_WAKEUP 8 /* (thread, other_cap) */ #define EVENT_GC_START 9 /* () */ #define EVENT_GC_END 10 /* () */ @@ -114,6 +113,7 @@ /* 13, 14 deprecated */ #define EVENT_CREATE_SPARK_THREAD 15 /* (spark_thread) */ #define EVENT_LOG_MSG 16 /* (message ...) */ +/* EVENT_STARTUP should be deprecated at some point */ #define EVENT_STARTUP 17 /* (num_capabilities) */ #define EVENT_BLOCK_MARKER 18 /* (size, end_time, capability) */ #define EVENT_USER_MSG 19 /* (message ...) */ @@ -132,7 +132,7 @@ #define EVENT_PROGRAM_ENV 31 /* (capset, environment_vector) */ #define EVENT_OSPROCESS_PID 32 /* (capset, pid) */ #define EVENT_OSPROCESS_PPID 33 /* (capset, parent_pid) */ -#define EVENT_SPARK_COUNTERS 34 /* (crt,dud,ovf,cnv,fiz,gcd,rem) */ +#define EVENT_SPARK_COUNTERS 34 /* (crt,dud,ovf,cnv,gcd,fiz,rem) */ #define EVENT_SPARK_CREATE 35 /* () */ #define EVENT_SPARK_DUD 36 /* () */ #define EVENT_SPARK_OVERFLOW 37 /* () */ @@ -140,11 +140,30 @@ #define EVENT_SPARK_STEAL 39 /* (victim_cap) */ #define EVENT_SPARK_FIZZLE 40 /* () */ #define EVENT_SPARK_GC 41 /* () */ -#define EVENT_INTERN_STRING 42 /* (string, id) */ +#define EVENT_INTERN_STRING 42 /* (string, id) {not used by ghc} */ #define EVENT_WALL_CLOCK_TIME 43 /* (capset, unix_epoch_seconds, nanoseconds) */ #define EVENT_THREAD_LABEL 44 /* (thread, name_string) */ +#define EVENT_CAP_CREATE 45 /* (cap) */ +#define EVENT_CAP_DELETE 46 /* (cap) */ +#define EVENT_CAP_DISABLE 47 /* (cap) */ +#define EVENT_CAP_ENABLE 48 /* (cap) */ +#define EVENT_HEAP_ALLOCATED 49 /* (heap_capset, alloc_bytes) */ +#define EVENT_HEAP_SIZE 50 /* (heap_capset, size_bytes) */ +#define EVENT_HEAP_LIVE 51 /* (heap_capset, live_bytes) */ +#define EVENT_HEAP_INFO_GHC 52 /* (heap_capset, n_generations, + max_heap_size, alloc_area_size, + mblock_size, block_size) */ +#define EVENT_GC_STATS_GHC 53 /* (heap_capset, generation, + copied_bytes, slop_bytes, frag_bytes, + par_n_threads, + par_max_copied, par_tot_copied) */ +#define EVENT_GC_GLOBAL_SYNC 54 /* () */ +#define EVENT_TASK_CREATE 55 /* (taskID, cap, tid) */ +#define EVENT_TASK_MIGRATE 56 /* (taskID, cap, new_cap) */ +#define EVENT_TASK_DELETE 57 /* (taskID) */ +#define EVENT_USER_MARKER 58 /* (marker_name) */ -/* Range 45 - 59 is available for new GHC and common events */ +/* Range 59 - 59 is available for new GHC and common events. */ /* Range 60 - 80 is used by eden for parallel tracing * see http://www.mathematik.uni-marburg.de/~eden/ @@ -169,6 +188,8 @@ /* Range 100 - 139 is reserved for Mercury, see below. */ +/* Range 140 - 159 is reserved for Perf events, see below. */ + /* * The highest event code +1 that ghc itself emits. Note that some event * ranges higher than this are reserved but not currently emitted by ghc. @@ -182,6 +203,8 @@ still need to parse them, see GHC.RTS.Events.ghc6Parsers for details. */ #define EVENT_RUN_SPARK 5 /* (thread) */ #define EVENT_STEAL_SPARK 6 /* (thread, victim_cap) */ +/* shutdown replaced by EVENT_CAP_DELETE */ +#define EVENT_SHUTDOWN 7 /* () */ #if 0 /* ghc changed how it handles sparks so these are no longer applicable */ #define EVENT_CREATE_SPARK 13 /* (cap, thread) */ @@ -212,6 +235,18 @@ #define EVENT_MER_RELEASE_CONTEXT 110 /* (context id) */ #define EVENT_MER_ENGINE_SLEEPING 111 /* () */ #define EVENT_MER_CALLING_MAIN 113 /* () */ + + +/* + * These event types are parsed from hardware performance counters logs, + * such as the Linux Performance Counters data available through + * the perf subsystem. + */ + +#define EVENT_PERF_NAME 140 /* (perf_num, name) */ +#define EVENT_PERF_COUNTER 141 /* (perf_num, tid, period) */ +#define EVENT_PERF_TRACEPOINT 142 /* (perf_num, tid) */ + /* * Status values for EVENT_STOP_THREAD diff --git a/GHC/RTS/EventTypes.hs b/GHC/RTS/EventTypes.hs --- a/GHC/RTS/EventTypes.hs +++ b/GHC/RTS/EventTypes.hs @@ -3,6 +3,7 @@ module GHC.RTS.EventTypes where import Data.Word (Word8, Word16, Word32, Word64) +import Data.Binary -- EventType. type EventTypeNum = Word16 @@ -19,7 +20,16 @@ type RawThreadStopStatus = Word16 type StringId = Word32 type Capset = Word32 +type PerfEventTypeNum = Word32 +type TaskId = Word64 +type PID = Word32 +newtype KernelThreadId = KernelThreadId { kernelThreadId :: Word64 } + deriving (Eq, Ord, Show) +instance Binary KernelThreadId where + put (KernelThreadId tid) = put tid + get = fmap KernelThreadId get + -- Types for Parallel-RTS Extension type ProcessId = Word32 type MachineId = Word16 @@ -55,10 +65,16 @@ + sz_time + sz_cap) sz_pid :: EventTypeSize sz_pid = 4 +sz_taskid :: EventTypeSize +sz_taskid = 8 +sz_kernel_tid :: EventTypeSize +sz_kernel_tid = 8 sz_th_stop_status :: EventTypeSize sz_th_stop_status = 2 sz_string_id :: EventTypeSize sz_string_id = 4 +sz_perf_num :: EventTypeSize +sz_perf_num = 4 -- Sizes for Parallel-RTS event fields sz_procid, sz_mid, sz_mes, sz_realtime, sz_msgtag :: EventTypeSize @@ -124,6 +140,8 @@ -- init and shutdown | Startup { n_caps :: Int } + -- EVENT_SHUTDOWN is replaced by EVENT_CAP_DELETE and GHC 7.6+ + -- no longer generate the event; should be removed at some point | Shutdown { } -- thread scheduling @@ -161,6 +179,17 @@ | SparkFizzle { } | SparkGC { } + -- tasks + | TaskCreate { taskId :: TaskId, + cap :: {-# UNPACK #-}!Int, + tid :: {-# UNPACK #-}!KernelThreadId + } + | TaskMigrate { taskId :: TaskId, + cap :: {-# UNPACK #-}!Int, + new_cap :: {-# UNPACK #-}!Int + } + | TaskDelete { taskId :: TaskId } + -- garbage collection | RequestSeqGC { } | RequestParGC { } @@ -169,7 +198,44 @@ | GCIdle { } | GCDone { } | EndGC { } + | GlobalSyncGC { } + | GCStatsGHC { heapCapset :: {-# UNPACK #-}!Capset + , gen :: {-# UNPACK #-}!Int + , copied :: {-# UNPACK #-}!Word64 + , slop, frag :: {-# UNPACK #-}!Word64 + , parNThreads :: {-# UNPACK #-}!Int + , parMaxCopied :: {-# UNPACK #-}!Word64 + , parTotCopied :: {-# UNPACK #-}!Word64 + } + -- heap statistics + | HeapAllocated { heapCapset :: {-# UNPACK #-}!Capset + , allocBytes :: {-# UNPACK #-}!Word64 + } + | HeapSize { heapCapset :: {-# UNPACK #-}!Capset + , sizeBytes :: {-# UNPACK #-}!Word64 + } + | HeapLive { heapCapset :: {-# UNPACK #-}!Capset + , liveBytes :: {-# UNPACK #-}!Word64 + } + | HeapInfoGHC { heapCapset :: {-# UNPACK #-}!Capset + , gens :: {-# UNPACK #-}!Int + , maxHeapSize :: {-# UNPACK #-}!Word64 + , allocAreaSize :: {-# UNPACK #-}!Word64 + , mblockSize :: {-# UNPACK #-}!Word64 + , blockSize :: {-# UNPACK #-}!Word64 + } + + -- adjusting the number of capabilities on the fly + | CapCreate { cap :: {-# UNPACK #-}!Int + } + | CapDelete { cap :: {-# UNPACK #-}!Int + } + | CapDisable { cap :: {-# UNPACK #-}!Int + } + | CapEnable { cap :: {-# UNPACK #-}!Int + } + -- capability sets | CapsetCreate { capset :: {-# UNPACK #-}!Capset , capsetType :: CapsetType @@ -194,10 +260,10 @@ , env :: [String] } | OsProcessPid { capset :: {-# UNPACK #-}!Capset - , pid :: {-# UNPACK #-}!Word32 + , pid :: {-# UNPACK #-}!PID } | OsProcessParentPid { capset :: {-# UNPACK #-}!Capset - , ppid :: {-# UNPACK #-}!Word32 + , ppid :: {-# UNPACK #-}!PID } | WallClockTime { capset :: {-# UNPACK #-}!Capset , sec :: {-# UNPACK #-}!Word64 @@ -207,9 +273,10 @@ -- messages | Message { msg :: String } | UserMessage { msg :: String } + | UserMarker { markername :: String } -- Events emitted by a parallel RTS - -- Programme /process info (tools might prefer newer variants above) + -- Program /process info (tools might prefer newer variants above) | Version { version :: String } | ProgramInvocation { commandline :: String } -- startup and shutdown (incl. real start time, not first log entry) @@ -287,6 +354,18 @@ } | MerCapSleeping | MerCallingMain + + -- perf events + | PerfName { perfNum :: {-# UNPACK #-}!PerfEventTypeNum + , name :: String + } + | PerfCounter { perfNum :: {-# UNPACK #-}!PerfEventTypeNum + , tid :: {-# UNPACK #-}!KernelThreadId + , period :: {-# UNPACK #-}!Word64 + } + | PerfTracepoint { perfNum :: {-# UNPACK #-}!PerfEventTypeNum + , tid :: {-# UNPACK #-}!KernelThreadId + } deriving Show diff --git a/GHC/RTS/Events.hs b/GHC/RTS/Events.hs --- a/GHC/RTS/Events.hs +++ b/GHC/RTS/Events.hs @@ -2,7 +2,7 @@ {-# OPTIONS_GHC -funbox-strict-fields -fwarn-incomplete-patterns #-} {- - Authors: Donnie Jones, Simon Marlow, Paul Bone, Mischa Dieterle, - - Thomas Horstmeyer, Duncan Coutts, Jost Berthold + - Thomas Horstmeyer, Duncan Coutts, Jost Berthold, Mikolaj Konarski - Events.hs - Parser functions for GHC RTS EventLog framework, parallel version. -} @@ -19,6 +19,8 @@ CapsetType(..), Timestamp, ThreadId, + TaskId, + KernelThreadId(..), -- some types for the parallel RTS ProcessId, MachineId, @@ -36,7 +38,11 @@ -- * Printing showEventInfo, showThreadStopStatus, - ppEventLog, ppEventType, ppEvent + ppEventLog, ppEventType, ppEvent, + + -- * Perf events + nEVENT_PERF_NAME, nEVENT_PERF_COUNTER, nEVENT_PERF_TRACEPOINT, + sz_perf_num, sz_kernel_tid ) where {- Libraries. -} @@ -146,6 +152,8 @@ Right es -> es } )), + -- EVENT_SHUTDOWN is replaced by EVENT_CAP_DELETE and GHC 7.6+ + -- no longer generate the event; should be removed at some point (simpleEvent EVENT_SHUTDOWN Shutdown), (simpleEvent EVENT_REQUEST_SEQ_GC RequestSeqGC), @@ -162,6 +170,70 @@ (simpleEvent EVENT_GC_END EndGC), + (simpleEvent EVENT_GC_GLOBAL_SYNC GlobalSyncGC), + + (FixedSizeParser EVENT_GC_STATS_GHC (sz_capset + 2 + 5*8 + 4) (do -- (heap_capset, generation, copied_bytes, slop_bytes, frag_bytes, par_n_threads, par_max_copied, par_tot_copied) + heapCapset <- getE + gen <- getE :: GetEvents Word16 + copied <- getE :: GetEvents Word64 + slop <- getE :: GetEvents Word64 + frag <- getE :: GetEvents Word64 + parNThreads <- getE :: GetEvents Word32 + parMaxCopied <- getE :: GetEvents Word64 + parTotCopied <- getE :: GetEvents Word64 + return GCStatsGHC{ gen = fromIntegral gen + , parNThreads = fromIntegral parNThreads + , ..} + )), + + (FixedSizeParser EVENT_HEAP_ALLOCATED (sz_capset + 8) (do -- (heap_capset, alloc_bytes) + heapCapset <- getE + allocBytes <- getE + return HeapAllocated{..} + )), + + (FixedSizeParser EVENT_HEAP_SIZE (sz_capset + 8) (do -- (heap_capset, size_bytes) + heapCapset <- getE + sizeBytes <- getE + return HeapSize{..} + )), + + (FixedSizeParser EVENT_HEAP_LIVE (sz_capset + 8) (do -- (heap_capset, live_bytes) + heapCapset <- getE + liveBytes <- getE + return HeapLive{..} + )), + + (FixedSizeParser EVENT_HEAP_INFO_GHC (sz_capset + 2 + 4*8) (do -- (heap_capset, n_generations, max_heap_size, alloc_area_size, mblock_size, block_size) + heapCapset <- getE + gens <- getE :: GetEvents Word16 + maxHeapSize <- getE :: GetEvents Word64 + allocAreaSize <- getE :: GetEvents Word64 + mblockSize <- getE :: GetEvents Word64 + blockSize <- getE :: GetEvents Word64 + return HeapInfoGHC{gens = fromIntegral gens, ..} + )), + + (FixedSizeParser EVENT_CAP_CREATE (sz_cap) (do -- (cap) + cap <- getE :: GetEvents CapNo + return CapCreate{cap = fromIntegral cap} + )), + + (FixedSizeParser EVENT_CAP_DELETE (sz_cap) (do -- (cap) + cap <- getE :: GetEvents CapNo + return CapDelete{cap = fromIntegral cap} + )), + + (FixedSizeParser EVENT_CAP_DISABLE (sz_cap) (do -- (cap) + cap <- getE :: GetEvents CapNo + return CapDisable{cap = fromIntegral cap} + )), + + (FixedSizeParser EVENT_CAP_ENABLE (sz_cap) (do -- (cap) + cap <- getE :: GetEvents CapNo + return CapEnable{cap = fromIntegral cap} + )), + (FixedSizeParser EVENT_CAPSET_CREATE (sz_capset + sz_capset_type) (do -- (capset, capset_type) cs <- getE ct <- fmap mkCapsetType getE @@ -204,7 +276,6 @@ return WallClockTime{capset=cs,sec=s,nsec=ns} )), - (VariableSizeParser EVENT_LOG_MSG (do -- (msg) num <- getE :: GetEvents Word16 string <- getString num @@ -215,6 +286,11 @@ string <- getString num return UserMessage{ msg = string } )), + (VariableSizeParser EVENT_USER_MARKER (do -- (markername) + num <- getE :: GetEvents Word16 + string <- getString num + return UserMarker{ markername = string } + )), (VariableSizeParser EVENT_PROGRAM_ARGS (do -- (capset, [arg]) num <- getE :: GetEvents Word16 cs <- getE @@ -320,16 +396,17 @@ return CreateSparkThread{sparkThread=st} )), - (FixedSizeParser EVENT_SPARK_COUNTERS (7*8) (do -- (crt,dud,ovf,cnv,fiz,gcd,rem) + (FixedSizeParser EVENT_SPARK_COUNTERS (7*8) (do -- (crt,dud,ovf,cnv,gcd,fiz,rem) crt <- getE :: GetEvents Word64 dud <- getE :: GetEvents Word64 ovf <- getE :: GetEvents Word64 cnv <- getE :: GetEvents Word64 - fiz <- getE :: GetEvents Word64 gcd <- getE :: GetEvents Word64 + fiz <- getE :: GetEvents Word64 rem <- getE :: GetEvents Word64 return SparkCounters{sparksCreated = crt, sparksDud = dud, sparksOverflowed = ovf, sparksConverted = cnv, + -- Warning: order of fiz and gcd reversed! sparksFizzled = fiz, sparksGCd = gcd, sparksRemaining = rem} )), @@ -345,6 +422,25 @@ (simpleEvent EVENT_SPARK_FIZZLE SparkFizzle), (simpleEvent EVENT_SPARK_GC SparkGC), + (FixedSizeParser EVENT_TASK_CREATE (sz_taskid + sz_cap + sz_kernel_tid) (do -- (taskID, cap, tid) + taskId <- getE :: GetEvents TaskId + cap <- getE :: GetEvents CapNo + tid <- getE :: GetEvents KernelThreadId + return TaskCreate{ taskId, cap = fromIntegral cap, tid } + )), + (FixedSizeParser EVENT_TASK_MIGRATE (sz_taskid + sz_cap*2) (do -- (taskID, cap, new_cap) + taskId <- getE :: GetEvents TaskId + cap <- getE :: GetEvents CapNo + new_cap <- getE :: GetEvents CapNo + return TaskMigrate{ taskId, cap = fromIntegral cap + , new_cap = fromIntegral new_cap + } + )), + (FixedSizeParser EVENT_TASK_DELETE (sz_taskid) (do -- (taskID) + taskId <- getE :: GetEvents TaskId + return TaskDelete{ taskId } + )), + (FixedSizeParser EVENT_THREAD_WAKEUP (sz_tid + sz_cap) (do -- (thread, other_cap) t <- getE oc <- getE :: GetEvents CapNo @@ -581,6 +677,28 @@ ] +perfParsers = [ + (VariableSizeParser EVENT_PERF_NAME (do -- (perf_num, name) + num <- getE :: GetEvents Word16 + perfNum <- getE + name <- getString (num - sz_perf_num) + return PerfName{perfNum, name} + )), + + (FixedSizeParser EVENT_PERF_COUNTER (sz_perf_num + sz_kernel_tid + 8) (do -- (perf_num, tid, period) + perfNum <- getE + tid <- getE + period <- getE + return PerfCounter{perfNum, tid, period} + )), + + (FixedSizeParser EVENT_PERF_TRACEPOINT (sz_perf_num + sz_kernel_tid) (do -- (perf_num, tid) + perfNum <- getE + tid <- getE + return PerfTracepoint{perfNum, tid} + )) + ] + getData :: GetEvents Data getData = do db <- getE :: GetEvents Marker @@ -624,9 +742,9 @@ event_parsers = if is_ghc_6 then standardParsers ++ ghc6Parsers ++ parRTSParsers sz_old_tid - else standardParsers ++ ghc7Parsers ++ - parRTSParsers sz_tid ++ - mercuryParsers + else standardParsers ++ ghc7Parsers + ++ parRTSParsers sz_tid + ++ mercuryParsers ++ perfParsers parsers = mkEventTypeParsers imap event_parsers dat <- runReaderT getData (EventParsers parsers) return (EventLog header dat) @@ -742,6 +860,14 @@ printf "spark fizzled" SparkGC -> printf "spark GCed" + TaskCreate taskId cap tid -> + printf "task 0x%x created on cap %d with OS kernel thread %d" + taskId cap (kernelThreadId tid) + TaskMigrate taskId cap new_cap -> + printf "task 0x%x migrated from cap %d to cap %d" + taskId cap new_cap + TaskDelete taskId -> + printf "task 0x%x deleted" taskId Shutdown -> printf "shutting down" WakeupThread thread otherCap -> @@ -762,10 +888,32 @@ printf "GC idle" GCDone -> printf "GC done" + GlobalSyncGC -> + printf "all caps stopped for GC" + GCStatsGHC{..} -> + printf "GC stats for heap capset %d: generation %d, %d bytes copied, %d bytes slop, %d bytes fragmentation, %d par threads, %d bytes max par copied, %d bytes total par copied" heapCapset gen copied slop frag parNThreads parMaxCopied parTotCopied + HeapAllocated{..} -> + printf "allocated on heap capset %d: %d total bytes till now" heapCapset allocBytes + HeapSize{..} -> + printf "size of heap capset %d: %d bytes" heapCapset sizeBytes + HeapLive{..} -> + printf "live data in heap capset %d: %d bytes" heapCapset liveBytes + HeapInfoGHC{..} -> + printf "heap stats for heap capset %d: generations %d, %d bytes max heap size, %d bytes alloc area size, %d bytes mblock size, %d bytes block size" heapCapset gens maxHeapSize allocAreaSize mblockSize blockSize + CapCreate{cap} -> + printf "created cap %d" cap + CapDelete{cap} -> + printf "deleted cap %d" cap + CapDisable{cap} -> + printf "disabled cap %d" cap + CapEnable{cap} -> + printf "enabled cap %d" cap Message msg -> msg UserMessage msg -> msg + UserMarker markername -> + printf "marker: %s" markername CapsetCreate cs ct -> printf "created capset %d of type %s" cs (show ct) CapsetDelete cs -> @@ -850,6 +998,14 @@ "Capability going to sleep" MerCallingMain -> "About to call the program entry point" + PerfName{perfNum, name} -> + printf "perf event %d named \"%s\"" perfNum name + PerfCounter{perfNum, tid, period} -> + printf "perf event counter %d incremented by %d in OS thread %d" + perfNum (period + 1) (kernelThreadId tid) + PerfTracepoint{perfNum, tid} -> + printf "perf event tracepoint %d reached in OS thread %d" + perfNum (kernelThreadId tid) showThreadStopStatus :: ThreadStopStatus -> String showThreadStopStatus HeapOverflow = "heap overflow" @@ -965,6 +1121,7 @@ ThreadLabel {} -> EVENT_THREAD_LABEL StartGC {} -> EVENT_GC_START EndGC {} -> EVENT_GC_END + GlobalSyncGC {} -> EVENT_GC_GLOBAL_SYNC RequestSeqGC {} -> EVENT_REQUEST_SEQ_GC RequestParGC {} -> EVENT_REQUEST_PAR_GC CreateSparkThread {} -> EVENT_CREATE_SPARK_THREAD @@ -976,13 +1133,26 @@ SparkSteal {} -> EVENT_SPARK_STEAL SparkFizzle {} -> EVENT_SPARK_FIZZLE SparkGC {} -> EVENT_SPARK_GC + TaskCreate {} -> EVENT_TASK_CREATE + TaskMigrate {} -> EVENT_TASK_MIGRATE + TaskDelete {} -> EVENT_TASK_DELETE Message {} -> EVENT_LOG_MSG Startup {} -> EVENT_STARTUP EventBlock {} -> EVENT_BLOCK_MARKER UserMessage {} -> EVENT_USER_MSG + UserMarker {} -> EVENT_USER_MARKER GCIdle {} -> EVENT_GC_IDLE GCWork {} -> EVENT_GC_WORK GCDone {} -> EVENT_GC_DONE + GCStatsGHC{} -> EVENT_GC_STATS_GHC + HeapAllocated{} -> EVENT_HEAP_ALLOCATED + HeapSize{} -> EVENT_HEAP_SIZE + HeapLive{} -> EVENT_HEAP_LIVE + HeapInfoGHC{} -> EVENT_HEAP_INFO_GHC + CapCreate{} -> EVENT_CAP_CREATE + CapDelete{} -> EVENT_CAP_DELETE + CapDisable{} -> EVENT_CAP_DISABLE + CapEnable{} -> EVENT_CAP_ENABLE CapsetCreate {} -> EVENT_CAPSET_CREATE CapsetDelete {} -> EVENT_CAPSET_DELETE CapsetAssignCap {} -> EVENT_CAPSET_ASSIGN_CAP @@ -1021,7 +1191,15 @@ MerReleaseThread _ -> EVENT_MER_RELEASE_CONTEXT MerCapSleeping -> EVENT_MER_ENGINE_SLEEPING MerCallingMain -> EVENT_MER_CALLING_MAIN + PerfName {} -> nEVENT_PERF_NAME + PerfCounter {} -> nEVENT_PERF_COUNTER + PerfTracepoint {} -> nEVENT_PERF_TRACEPOINT +nEVENT_PERF_NAME, nEVENT_PERF_COUNTER, nEVENT_PERF_TRACEPOINT :: EventTypeNum +nEVENT_PERF_NAME = EVENT_PERF_NAME +nEVENT_PERF_COUNTER = EVENT_PERF_COUNTER +nEVENT_PERF_TRACEPOINT = EVENT_PERF_TRACEPOINT + putEvent :: Event -> PutEvents () putEvent (Event t spec) = do putType (eventTypeNum spec) @@ -1088,8 +1266,9 @@ putE dud putE ovf putE cnv - putE fiz + -- Warning: order of fiz and gcd reversed! putE gcd + putE fiz putE rem putEventSpec SparkCreate = do @@ -1146,6 +1325,64 @@ putEventSpec EndGC = do return () +putEventSpec GlobalSyncGC = do + return () + +putEventSpec (TaskCreate taskId cap tid) = do + putE taskId + putCap cap + putE tid + +putEventSpec (TaskMigrate taskId cap new_cap) = do + putE taskId + putCap cap + putCap new_cap + +putEventSpec (TaskDelete taskId) = do + putE taskId + +putEventSpec GCStatsGHC{..} = do + putE heapCapset + putE (fromIntegral gen :: Word16) + putE copied + putE slop + putE frag + putE (fromIntegral parNThreads :: Word32) + putE parMaxCopied + putE parTotCopied + +putEventSpec HeapAllocated{..} = do + putE heapCapset + putE allocBytes + +putEventSpec HeapSize{..} = do + putE heapCapset + putE sizeBytes + +putEventSpec HeapLive{..} = do + putE heapCapset + putE liveBytes + +putEventSpec HeapInfoGHC{..} = do + putE heapCapset + putE (fromIntegral gens :: Word16) + putE maxHeapSize + putE allocAreaSize + putE mblockSize + putE blockSize + +putEventSpec CapCreate{cap} = do + putCap cap + +putEventSpec CapDelete{cap} = do + putCap cap + +putEventSpec CapDisable{cap} = do + putCap cap + +putEventSpec CapEnable{cap} = do + putCap cap + putEventSpec (CapsetCreate cs ct) = do putE cs putE $ case ct of @@ -1166,19 +1403,19 @@ putCap cp putEventSpec (RtsIdentifier cs rts) = do - putE (fromIntegral (length rts) + 4 :: Word16) + putE (fromIntegral (length rts) + sz_capset :: Word16) putE cs putEStr rts putEventSpec (ProgramArgs cs as) = do let as' = unsep as - putE (fromIntegral (length as') + 4 :: Word16) + putE (fromIntegral (length as') + sz_capset :: Word16) putE cs mapM_ putE as' putEventSpec (ProgramEnv cs es) = do let es' = unsep es - putE (fromIntegral (length es') + 4 :: Word16) + putE (fromIntegral (length es') + sz_capset :: Word16) putE cs mapM_ putE es' @@ -1203,6 +1440,10 @@ putE (fromIntegral (length s) :: Word16) mapM_ putE s +putEventSpec (UserMarker s) = do + putE (fromIntegral (length s) :: Word16) + mapM_ putE s + putEventSpec (UnknownEvent {}) = error "putEventSpec UnknownEvent" putEventSpec (InternString str id) = do @@ -1303,6 +1544,20 @@ putEventSpec MerCapSleeping = return () putEventSpec MerCallingMain = return () + +putEventSpec PerfName{..} = do + putE (fromIntegral (length name) + sz_perf_num :: Word16) + putE perfNum + mapM_ putE name + +putEventSpec PerfCounter{..} = do + putE perfNum + putE tid + putE period + +putEventSpec PerfTracepoint{..} = do + putE perfNum + putE tid -- [] == [] -- [x] == x\0 diff --git a/GHC/RTS/Events/Analysis.hs b/GHC/RTS/Events/Analysis.hs --- a/GHC/RTS/Events/Analysis.hs +++ b/GHC/RTS/Events/Analysis.hs @@ -64,7 +64,7 @@ | otherwise = Right s -- | The `validate` function takes a machine and a list of inputs. The machine --- is started from its initial state and run agains the inputs in turn. +-- is started from its initial state and run against the inputs in turn. -- It returns the state and input on failure, and just the state on success. validate :: Machine s i -> [i] -> Either (s, i) s validate m = foldl (>>=) (Right (initial m)) . map (flip (step m)) @@ -280,4 +280,3 @@ Nothing -> return m else return m return (m', r') - diff --git a/GHC/RTS/Events/Analysis/Capability.hs b/GHC/RTS/Events/Analysis/Capability.hs --- a/GHC/RTS/Events/Analysis/Capability.hs +++ b/GHC/RTS/Events/Analysis/Capability.hs @@ -2,6 +2,8 @@ ( capabilityThreadPoolMachine , capabilityThreadRunMachine , capabilityThreadIndexer + , capabilityTaskPoolMachine + , capabilityTaskOSMachine ) where @@ -40,13 +42,13 @@ where insertThread :: ThreadId -> Int -> Map ThreadId Int -> Maybe (Map ThreadId Int) insertThread threadId capId m - | threadId `elem` M.keys m = Nothing -- The thread already exists - | otherwise = Just $ M.insert threadId capId m + | threadId `M.member` m = Nothing -- The thread already exists + | otherwise = Just $ M.insert threadId capId m deleteThread :: ThreadId -> Map ThreadId Int -> Maybe (Map ThreadId Int) deleteThread threadId m - | notElem threadId . M.keys $ m = Nothing -- The thread doesn't exist - | otherwise = Just $ M.delete threadId m + | threadId `M.notMember` m = Nothing -- The thread doesn't exist + | otherwise = Just $ M.delete threadId m -- | This state machine tracks threads running on capabilities, only one thread -- may run on a capability at a time. @@ -76,7 +78,7 @@ where runThread :: Int -> ThreadId -> Map Int ThreadId -> Maybe (Map Int ThreadId) runThread capId threadId m - | M.member capId m = Nothing -- A thread is already on this cap + | capId `M.member` m = Nothing -- A thread is already on this cap | threadId `elem` M.elems m = Nothing -- This thread is already on a cap | otherwise = Just $ M.insert capId threadId m stopThread :: ThreadId -> Map Int ThreadId -> Maybe (Map Int ThreadId) @@ -98,3 +100,110 @@ _ -> mThreadId where mThreadId = ce_cap capEvent >>= (\capId -> M.lookup capId m) + +-- | This state machine tracks Haskell tasks, represented by TaskId, +-- residing on capabilities. +-- Each Haskell task can only reside on one capability, but can be migrated +-- between them. +capabilityTaskPoolMachine :: Machine (Map TaskId Int) CapEvent +capabilityTaskPoolMachine = Machine + { initial = M.empty + , final = const False + , alpha = capabilityTaskPoolMachineAlpha + , delta = capabilityTaskPoolMachineDelta + } + where + capabilityTaskPoolMachineAlpha capEvent = case spec . ce_event $ capEvent of + TaskCreate{} -> True + TaskDelete{} -> True + TaskMigrate{} -> True + _ -> False + + capabilityTaskPoolMachineDelta mapping capEvent = do + case spec . ce_event $ capEvent of + TaskCreate {taskId, cap} -> insertTask taskId cap mapping + TaskDelete {taskId} -> deleteTask taskId Nothing mapping + TaskMigrate {taskId, cap, new_cap} -> + deleteTask taskId (Just cap) mapping >>= + insertTask taskId new_cap + _ -> Nothing + where + insertTask :: TaskId -> Int -> Map TaskId Int + -> Maybe (Map TaskId Int) + insertTask taskId cap m + | taskId `M.member` m = Nothing -- The task already exists. + | otherwise = Just $ M.insert taskId cap m + + deleteTask :: TaskId -> Maybe Int -> Map TaskId Int + -> Maybe (Map TaskId Int) + deleteTask taskId expectedcap m + | Just oldcap <- M.lookup taskId m + , maybe True (==oldcap) expectedcap + = Just $ M.delete taskId m + | otherwise + = Nothing -- The task doesn't exist, or does but with an unexpected cap. + +-- | This state machine tracks Haskell tasks (represented by the KernelThreadId +-- of their OS thread) residing on capabilities and additionally +-- tracks the (immutable) assignment of OS thread ids (KernelThreadId) +-- to tasks ids (TaskId). +-- Each Haskell task can only reside on one capability, but can be migrated +-- between them. +-- +-- Invariant for the @(Map KernelThreadId Int, Map TaskId KernelThreadId)@ +-- type: the second map is an injection (verified by the machine +-- in 'insertTaskOS') and the following sets are equal: +-- keys of the fist map and values of the second +-- (follows from the construction of the maps by the machine). +-- +-- The machine verifies as much as 'capabilityTaskPoolMachine' and additionally +-- the data invariant, and offers a richer verification profile. +capabilityTaskOSMachine :: Machine (Map KernelThreadId Int, + Map TaskId KernelThreadId) + CapEvent +capabilityTaskOSMachine = Machine + { initial = (M.empty, M.empty) + , final = const False + , alpha = capabilityTaskOSMachineAlpha + , delta = capabilityTaskOSMachineDelta + } + where + capabilityTaskOSMachineAlpha capEvent = case spec . ce_event $ capEvent of + TaskCreate{} -> True + TaskDelete{} -> True + TaskMigrate{} -> True + _ -> False + + capabilityTaskOSMachineDelta mapping capEvent = do + case spec . ce_event $ capEvent of + TaskCreate {taskId, cap, tid} -> insertTaskOS taskId cap tid mapping + TaskDelete {taskId} -> deleteTaskOS taskId mapping + TaskMigrate {taskId, new_cap} -> migrateTaskOS taskId new_cap mapping + _ -> Nothing + where + insertTaskOS :: TaskId -> Int -> KernelThreadId + -> (Map KernelThreadId Int, Map TaskId KernelThreadId) + -> Maybe (Map KernelThreadId Int, Map TaskId KernelThreadId) + insertTaskOS taskId cap tid (m, ma) + | taskId `M.member` ma = Nothing -- The task already exists. + | tid `M.member` m = Nothing -- The OS thread already exists. + | otherwise = Just (M.insert tid cap m, + M.insert taskId tid ma) + + deleteTaskOS :: TaskId -> (Map KernelThreadId Int, + Map TaskId KernelThreadId) + -> Maybe (Map KernelThreadId Int, Map TaskId KernelThreadId) + deleteTaskOS taskId (m, ma) = + case M.lookup taskId ma of + Nothing -> Nothing -- The task doesn't exist. + Just tid -> Just (M.delete tid m, + M.delete taskId ma) + + migrateTaskOS :: TaskId -> Int -> (Map KernelThreadId Int, + Map TaskId KernelThreadId) + -> Maybe (Map KernelThreadId Int, Map TaskId KernelThreadId) + migrateTaskOS taskId new_cap (m, ma) = + case M.lookup taskId ma of + Nothing -> Nothing -- The task doesn't exist. + Just tid -> Just (M.insert tid new_cap m, + ma) -- The assignment is immutable. diff --git a/GHC/RTS/Events/Merge.hs b/GHC/RTS/Events/Merge.hs --- a/GHC/RTS/Events/Merge.hs +++ b/GHC/RTS/Events/Merge.hs @@ -5,21 +5,37 @@ import GHC.RTS.Events import Data.Monoid import Data.List (foldl') +import qualified Data.Map as M import Data.Word (Word32, Word16) +-- TODO: add a merge mode where the events are synchronized using +-- the wall clock time event at the start of both eventlogs (for newer GHCs). +-- Such merge is not associative so we either need to take many arguments +-- or cope with eventlogs with many wall clock time events (assume they +-- are products of previous merges). To decide. + {- GHC numbers caps and capsets in sequential order, starting at 0. Threads are -similarly numbered, but start at 1. In order to merge logs 'x' and 'y', we -find the maximum values of each variable type in 'x', then increment each -variable in 'y' that amount. This guarantees that variables in each log don't -clash, and that the meaning of each reference to a thread/cap/capset is +similarly numbered, but start at 1. In order to merge logs 'x' and 'y', +we find the # of occupied numbers for each variable type in 'x', +then increment each variable in 'y' by that amount. +We assume that if a number is occupied, so are all lower numbers. +This guarantees that variables in each log don't clash, +and that the meaning of each reference to a thread/cap/capset is preserved. -} mergeEventLogs :: EventLog -> EventLog -> EventLog -mergeEventLogs (EventLog h1 (Data xs)) (EventLog h2 (Data ys)) | h1 == h2 - = EventLog h1 . Data . mergeOn time xs $ shift (maxVars xs) ys -mergeEventLogs _ _ = error "can't merge eventlogs with non-matching headers" +mergeEventLogs (EventLog h1 (Data xs)) (EventLog h2 (Data ys)) = + let headerMap = M.fromList . map (\ et@EventType {num} -> (num, et)) + m1 = headerMap $ eventTypes h1 + m2 = headerMap $ eventTypes h2 + combine et1 et2 | et1 == et2 = et1 + combine _ _ = error "can't merge eventlogs with inconsistent headers" + m = M.unionWith combine m1 m2 + h = Header $ M.elems m + in h == h `seq` -- Detect inconsistency ASAP. + EventLog h . Data . mergeOn time xs $ shift (maxVars xs) ys mergeOn :: Ord b => (a -> b) -> [a] -> [a] -> [a] mergeOn f [] ys = ys @@ -27,15 +43,16 @@ mergeOn f (x:xs) (y:ys) | f x <= f y = x : mergeOn f xs (y:ys) | otherwise = y : mergeOn f (x:xs) ys +-- TODO: rename, since these are not maximal values, but numbers of used values data MaxVars = MaxVars { mcapset :: !Word32 , mcap :: !Int , mthread :: !ThreadId } -- TODO introduce parallel RTS process and machine var.s instance Monoid MaxVars where - -- threads start at 1 - mempty = MaxVars 0 0 1 - mappend (MaxVars a b c) (MaxVars x y z) = MaxVars (max a x) (max b y) (max c z) + mempty = MaxVars 0 0 0 + mappend (MaxVars a b c) (MaxVars x y z) = + MaxVars (max a x) (b + y) (max c z) -- avoid space leaks: mconcat = foldl' mappend mempty @@ -44,19 +61,27 @@ isCap :: Int -> Bool isCap x = fromIntegral x /= ((-1) :: Word16) +-- For caps we find the maximum value by summing the @Startup@ declarations. +-- TODO: it's not trivial to add CapCreate since we don't know +-- if created caps are guaranteed to be numbered consecutively or not +-- (are they? is it asserted in GHC code somewhere?). We might instead +-- just scan all events mentioning a cap and take the maximum, +-- but it's a slower and much longer code, requiring constant maintenance. maxVars :: [Event] -> MaxVars maxVars = mconcat . map (maxSpec . spec) where -- only checking binding sites right now, sufficient? - maxSpec (Startup n) = mempty { mcap = n - 1 } + maxSpec (Startup n) = mempty { mcap = n } + -- Threads start at 1. maxSpec (CreateThread t) = mempty { mthread = t } maxSpec (CreateSparkThread t) = mempty { mthread = t } - maxSpec (CapsetCreate cs _) = mempty {mcapset = cs } + -- Capsets start at 0. + maxSpec (CapsetCreate cs _) = mempty {mcapset = cs + 1 } maxSpec (EventBlock _ _ es) = maxVars es maxSpec _ = mempty sh :: Num a => a -> a -> a -sh x y = x + y + 1 +sh x y = x + y shift :: MaxVars -> [Event] -> [Event] shift mv@(MaxVars mcs mc mt) = map (\(Event t s) -> Event t $ shift' s) @@ -69,15 +94,25 @@ shift' (StopThread t s) = StopThread (sh mt t) s shift' (ThreadRunnable t) = ThreadRunnable $ sh mt t shift' (MigrateThread t c) = MigrateThread (sh mt t) (sh mc c) - shift' (CreateSparkThread t) = CreateSparkThread (sh mt t) shift' (WakeupThread t c) = WakeupThread (sh mt t) (sh mc c) + shift' (ThreadLabel t l) = ThreadLabel (sh mt t) l + shift' (CreateSparkThread t) = CreateSparkThread (sh mt t) + shift' (SparkSteal c) = SparkSteal (sh mc c) + shift' (TaskCreate tk c tid) = TaskCreate tk (sh mc c) tid + shift' (TaskMigrate tk c1 c2) = TaskMigrate tk (sh mc c1) (sh mc c2) + shift' (CapCreate c) = CapCreate (sh mc c) -- TODO: correct? + shift' (CapDelete c) = CapDelete (sh mc c) -- TODO: correct? + shift' (CapDisable c) = CapDisable (sh mc c) + shift' (CapEnable c) = CapEnable (sh mc c) shift' (CapsetCreate cs cst) = CapsetCreate (sh mcs cs) cst shift' (CapsetDelete cs) = CapsetDelete (sh mcs cs) + shift' (CapsetAssignCap cs c) = CapsetAssignCap (sh mcs cs) (sh mc c) shift' (CapsetRemoveCap cs c) = CapsetRemoveCap (sh mcs cs) (sh mc c) shift' (RtsIdentifier cs rts) = RtsIdentifier (sh mcs cs) rts shift' (ProgramArgs cs as) = ProgramArgs (sh mcs cs) as shift' (ProgramEnv cs es) = ProgramEnv (sh mcs cs) es shift' (OsProcessPid cs pid) = OsProcessPid (sh mcs cs) pid shift' (OsProcessParentPid cs ppid) = OsProcessParentPid (sh mcs cs) ppid + shift' (WallClockTime cs sec nsec) = WallClockTime (sh mcs cs) sec nsec shift' x = x -- TODO extend by new shift for Eden events diff --git a/GhcEvents.hs b/GhcEvents.hs --- a/GhcEvents.hs +++ b/GhcEvents.hs @@ -30,7 +30,7 @@ command ["show", "threads", file] = do eventLog <- readLogOrDie file - let eventTypeMap = buildEventTypeMap . eventTypes . header $ eventLog + let eventTypeMap = buildEventTypeMap . eventTypes . header $ eventLog let capEvents = sortEvents . events . dat $ eventLog let mappings = rights . validates capabilityThreadRunMachine $ capEvents let indexes = map (uncurry capabilityThreadIndexer) $ zip mappings capEvents @@ -45,7 +45,7 @@ command ["show", "caps", file] = do eventLog <- readLogOrDie file - let eventTypeMap = buildEventTypeMap . eventTypes . header $ eventLog + let eventTypeMap = buildEventTypeMap . eventTypes . header $ eventLog let capEvents = sortEvents . events . dat $ eventLog let indexes = map ce_cap capEvents let capMap = M.fromListWith (++) . reverse $ zip indexes (map return capEvents) @@ -87,6 +87,18 @@ let result = validate capabilityThreadRunMachine capEvents putStrLn $ showValidate show show result +command ["validate", "taskpool", file] = do + eventLog <- readLogOrDie file + let capEvents = sortEvents . events . dat $ eventLog + let result = validate capabilityTaskPoolMachine capEvents + putStrLn $ showValidate show show result + +command ["validate", "tasks", file] = do + eventLog <- readLogOrDie file + let capEvents = sortEvents . events . dat $ eventLog + let result = validate capabilityTaskOSMachine capEvents + putStrLn $ showValidate show show result + command ["validate", "sparks", file] = do eventLog <- readLogOrDie file let capEvents = sortEvents . events . dat $ eventLog @@ -117,6 +129,18 @@ let result = simulate capabilityThreadRunMachine capEvents putStrLn . showProcess $ result +command ["simulate", "taskpool", file] = do + eventLog <- readLogOrDie file + let capEvents = sortEvents . events . dat $ eventLog + let result = simulate capabilityTaskPoolMachine capEvents + putStrLn . showProcess $ result + +command ["simulate", "tasks", file] = do + eventLog <- readLogOrDie file + let capEvents = sortEvents . events . dat $ eventLog + let result = simulate capabilityTaskOSMachine capEvents + putStrLn . showProcess $ result + command ["simulate", "sparks", file] = do eventLog <- readLogOrDie file let capEvents = sortEvents . events . dat $ eventLog @@ -168,11 +192,13 @@ , ("ghc-events validate threads :", "Validate thread states.") , ("ghc-events validate threadpool :", "Validate thread pool state.") , ("ghc-events validate threadrun :", "Validate thread running state.") + , ("ghc-events validate tasks :", "Validate task states.") , ("ghc-events validate sparks :", "Validate spark thread states.") , ("ghc-events simulate threads :", "Simulate thread states.") , ("ghc-events simulate threadpool :", "Simulate thread pool state.") , ("ghc-events simulate threadrun :", "Simulate thread running state.") + , ("ghc-events simulate tasks :", "Simulate task states.") , ("ghc-events simulate sparks :", "Simulate spark thread states.") , ("ghc-events profile threads :", "Profile thread states.") diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,21 @@ The Glasgow Haskell Compiler License -Copyright 2002, The University Court of the University of Glasgow. -All rights reserved. +Copyright 2002-2012, The University Court of the University of Glasgow +and others. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - + - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - + - Neither name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without -specific prior written permission. +specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, diff --git a/ghc-events-parallel.cabal b/ghc-events-parallel.cabal --- a/ghc-events-parallel.cabal +++ b/ghc-events-parallel.cabal @@ -1,5 +1,5 @@ name: ghc-events-parallel -version: 0.4.0.0 +version: 0.4.2.0 synopsis: Library and tool for parsing .eventlog files from parallel GHC description: Parses .eventlog files emitted by parallel GHC versions (6.12.3 and later). This package can replace the original @@ -18,25 +18,26 @@ Duncan Coutts , Nicolas Wu , Jost Berthold + Mikolaj Konarski maintainer: Eden group -bug-reports: to maintainer via mail +bug-reports: eden@mathematik.uni-marburg.de build-type: Simple +tested-with: GHC == 6.12.3, GHC == 7.4.1, GHC == 7.6.1, GHC == 7.6.3 cabal-version: >= 1.8 extra-source-files: GHC/RTS/EventLogFormat.h, - AUTHORS, test/*.eventlog -source-repository head - type: darcs - location: http://james.mathematik.uni-marburg.de:8080/darcs/jb/ghc-events-parallel/ +-- source-repository head +-- type: darcs +-- location: james.mathematik.uni-marburg.de:repos/jb/ghc-events-parallel/ library build-depends: base == 4.*, - mtl >= 1.1 && < 2.1, - containers >= 0.2 && < 0.5, - binary == 0.5.*, - bytestring == 0.9.*, - array >= 0.2 && < 0.5 + mtl >= 1.1 && < 3.0, + containers >= 0.2 && < 0.6, + binary >= 0.5 && < 0.8, + bytestring >= 0.9.0, + array >= 0.2 && < 0.6 exposed-modules: GHC.RTS.Events, GHC.RTS.Events.Merge GHC.RTS.Events.Analysis @@ -45,6 +46,7 @@ GHC.RTS.Events.Analysis.Thread other-modules: GHC.RTS.EventParserUtils, GHC.RTS.EventTypes + include-dirs: GHC/RTS extensions: RecordWildCards, NamedFieldPuns, BangPatterns, PatternGuards executable ghc-events @@ -56,3 +58,4 @@ type: exitcode-stdio-1.0 main-is: test/TestVersions.hs build-depends: base, mtl, containers, binary, bytestring, array + extensions: RecordWildCards, NamedFieldPuns, BangPatterns, PatternGuards diff --git a/ghc-events-parallel.cabal~ b/ghc-events-parallel.cabal~ new file mode 100644 --- /dev/null +++ b/ghc-events-parallel.cabal~ @@ -0,0 +1,61 @@ +name: ghc-events-parallel +version: 0.4.2.0 +synopsis: Library and tool for parsing .eventlog files from parallel GHC +description: Parses .eventlog files emitted by parallel GHC versions + (6.12.3 and later). This package can replace the original + ghc-events package and defines a superset of functions + and types. + Includes the ghc-events tool permitting, in particular, + to dump an event log file as text. +category: Development, GHC, Debug, Eden, Profiling, Trace +license: BSD3 +license-file: LICENSE +author: Donnie Jones , + Simon Marlow , + Paul Bone , + Mischa Dieterle , + Thomas Horstmeyer , + Duncan Coutts , + Nicolas Wu , + Jost Berthold + Mikolaj Konarski +maintainer: Eden group +bug-reports: eden@mathematik.uni-marburg.de +build-type: Simple +tested-with: GHC == 6.12.3, GHC == 7.4.1, GHC == 7.6.1, GHC == 7.6.3 +cabal-version: >= 1.8 +extra-source-files: GHC/RTS/EventLogFormat.h, + test/*.eventlog + +source-repository head + type: darcs + location: http://james.mathematik.uni-marburg.de:8080/darcs/jb/ghc-events-parallel/ + +library + build-depends: base == 4.*, + mtl >= 1.1 && < 3.0, + containers >= 0.2 && < 0.6, + binary >= 0.5 && < 0.8, + bytestring >= 0.9.0, + array >= 0.2 && < 0.6 + exposed-modules: GHC.RTS.Events, + GHC.RTS.Events.Merge + GHC.RTS.Events.Analysis + GHC.RTS.Events.Analysis.Capability + GHC.RTS.Events.Analysis.SparkThread + GHC.RTS.Events.Analysis.Thread + other-modules: GHC.RTS.EventParserUtils, + GHC.RTS.EventTypes + include-dirs: GHC/RTS + extensions: RecordWildCards, NamedFieldPuns, BangPatterns, PatternGuards + +executable ghc-events + main-is: GhcEvents.hs + build-depends: base, mtl, containers, binary, bytestring, array + extensions: RecordWildCards, NamedFieldPuns, BangPatterns, PatternGuards + +test-suite test-versions + type: exitcode-stdio-1.0 + main-is: test/TestVersions.hs + build-depends: base, mtl, containers, binary, bytestring, array + extensions: RecordWildCards, NamedFieldPuns, BangPatterns, PatternGuards diff --git a/test/TestVersions.hs b/test/TestVersions.hs new file mode 100644 --- /dev/null +++ b/test/TestVersions.hs @@ -0,0 +1,66 @@ +{- +This test parses sample event logs from each major GHC version and compares +the pretty printed output with reference output. + +When tests fail, use a diff tool to compare the output of "ghc-events show" with +the reference file. Resolve the differences in either the library code or the +reference file, and 'darcs record' the changes. + +Steps to produce event log and reference output: + $ ghc --make queens.hs -o queens-ghc-$VERSION -threaded -eventlog + $ queens-ghc-$VERSION 8 +RTS -N4 -ls + $ ghc-events show queens-ghc-$VERSION.eventlog > queens-ghc-$VERSION.eventlog.reference + +Where queens.hs is http://darcs.haskell.org/nofib/parallel/queens/Main.hs +-} + +import GHC.RTS.Events +import System.Exit + +files :: [FilePath] +files = map ("test/"++) + [ "queens-ghc-6.12.1.eventlog" + , "queens-ghc-7.0.2.eventlog" + , "mandelbrot-mmc-2011-06-14.eventlog" + , "mdlLogMPI1.eventlog" ] + +-- returns True on success +testFile :: FilePath -> IO Bool +testFile f = do + e <- readEventLogFromFile f + let oops s = putStrLn (f ++ ": failure" ++ s) >> return False + + case e of + Left m -> oops m + + Right newlogdata -> do + oldlog <- readFile (f ++ ".reference") + let newlog = ppEventLog newlogdata ++ "\n" in + if oldlog == newlog + then putStrLn (f ++ ": success") >> return True + else do print $ diffLines oldlog newlog + oops "pretty print output does not match" + +main = do + successes <- mapM testFile files + if and successes + then return () + else exitFailure + +-- +-- Code to help print the differences between a working test and a failing test. +-- + +diffLines o n = diff 1 (lines o) (lines n) + +diff :: Int -> [String] -> [String] -> String +diff _ [] [] = "Logs match" +diff l [] (n:ns) = "Extra lines in new log at line " ++ show l ++ ":\n" ++ + (unlines (n:ns)) +diff l (o:os) [] = "Missing lines in new log at line " ++ show l ++ ":\n" ++ + (unlines (o:os)) +diff l (o:os) (n:ns) = if (o == n) + then diff (l+1) os ns + else "Different lines at line " ++ show l ++ ":\n" ++ + "Original: " ++ o ++ + "New: " ++ n diff --git a/test/mandelbrot-mmc-2011-06-14.eventlog.reference b/test/mandelbrot-mmc-2011-06-14.eventlog.reference new file mode 100644 --- /dev/null +++ b/test/mandelbrot-mmc-2011-06-14.eventlog.reference @@ -0,0 +1,5597 @@ +Event Types: + 17: Startup (num_engines) (size 2) + 7: Shutdown (size 0) + 18: A block of events generated by a specific engine follows (size 14) + 0: A context is created or re-used (size 4) + 3: The context is being placed on the run queue (size 4) + 5: Run a spark from the local stack (size 8) + 6: Run a spark stolen from another engine (size 10) + 1: Run context (size 4) + 2: Context stopped (size 6) + 15: Create a context for executing a spark (size 4) + 16: A user-provided log message (size variable) + 9: Start GC (size 0) + 10: Stop GC (size 0) + 39: Register an id->string mapping (size variable) + 40: About to call main/2 (size 0) + 25: Create an engine set (size 6) + 26: Detete an engine set (size 4) + 27: Add an engine to an engine set (size 6) + 28: Add an engine to an engine set (size 6) + 29: The type of the runtime system for this capset (size variable) + 30: The command line arguments of this process (size variable) + 31: The environment variables this process inherited (size variable) + 32: The pid and parent pid of this process (size 8) + 103: A spark is being created (size 12) + 100: Start a parallel conjunction (dyn id, static id) (size 12) + 101: End a parallel conjunction (dyn id) (size 8) + 102: End a parallel conjunct (dyn id) (size 8) + 104: Create a future (future id) (size 12) + 105: Wait on a future without suspending (future id) (size 8) + 106: Wait on a future by suspending this thread (future id) (size 8) + 107: Signal a future (future id) (size 8) + 108: Engine begins looking for a context to execute (size 0) + 109: Engine begins attempt to steal work (size 0) + 110: Release this context to the free context pool (size 4) + +Events: + 0: created capset 0 of type CapsetOsProcess + 0: capset 0: RTS version "mmc-DEV" + 0: startup: 4 capabilities + 0: Register an id->string mapping + 0: Register an id->string mapping + 0: Register an id->string mapping + 0: Register an id->string mapping + 0: assigned cap 0 to capset 0 + 0: assigned cap 3 to capset 0 + 0: assigned cap 1 to capset 0 + 0: assigned cap 2 to capset 0 + 4198126: cap 0: creating thread 1 + 4199512: cap 0: running thread 1 + 9983902: cap 3: Looking for global thread to resume + 9987484: cap 3: Trying to steal a spark + 10575823: cap 1: Looking for global thread to resume + 10577452: cap 1: Trying to steal a spark + 10694043: cap 2: Looking for global thread to resume + 10694551: cap 2: Trying to steal a spark + 10852245: cap 0: spark fizzled + 11153997: cap 0: Start a parallel conjunction 0x2515150, static_id: 2 + 11155725: cap 0: Create spark for conjunction: 0x2515150 spark: 0x0 + 11165265: cap 0: Start a parallel conjunction 0x25151b0, static_id: 2 + 11165593: cap 0: Create spark for conjunction: 0x25151b0 spark: 0x1 + 11169886: cap 0: Start a parallel conjunction 0x2515210, static_id: 2 + 11170080: cap 0: Create spark for conjunction: 0x2515210 spark: 0x2 + 11172546: cap 0: Start a parallel conjunction 0x2515270, static_id: 2 + 11172730: cap 0: Create spark for conjunction: 0x2515270 spark: 0x3 + 11173041: cap 0: Start a parallel conjunction 0x25152d0, static_id: 2 + 11173338: cap 0: Create spark for conjunction: 0x25152d0 spark: 0x4 + 11173905: cap 0: Start a parallel conjunction 0x2515330, static_id: 2 + 11174107: cap 0: Create spark for conjunction: 0x2515330 spark: 0x5 + 11174143: cap 2: Trying to steal a spark + 11174413: cap 0: Start a parallel conjunction 0x2515390, static_id: 2 + 11174760: cap 0: Create spark for conjunction: 0x2515390 spark: 0x6 + 11175034: cap 0: Start a parallel conjunction 0x25153f0, static_id: 2 + 11175610: cap 0: Create spark for conjunction: 0x25153f0 spark: 0x7 + 11175853: cap 3: Trying to steal a spark + 11175885: cap 0: Start a parallel conjunction 0x2515450, static_id: 2 + 11177316: cap 2: stealing a spark from cap 0 + 11178108: cap 3: stealing a spark from cap 0 + 11198002: cap 0: Create spark for conjunction: 0x2515450 spark: 0x8 + 11198394: cap 0: Start a parallel conjunction 0x25154b0, static_id: 2 + 11198601: cap 0: Create spark for conjunction: 0x25154b0 spark: 0x9 + 11198880: cap 0: Start a parallel conjunction 0x2515510, static_id: 2 + 11199069: cap 0: Create spark for conjunction: 0x2515510 spark: 0xa + 11199352: cap 0: Start a parallel conjunction 0x2515570, static_id: 2 + 11199541: cap 0: Create spark for conjunction: 0x2515570 spark: 0xb + 11199829: cap 0: Start a parallel conjunction 0x25155d0, static_id: 2 + 11200014: cap 0: Create spark for conjunction: 0x25155d0 spark: 0xc + 11200275: cap 0: Start a parallel conjunction 0x2515630, static_id: 2 + 11200468: cap 0: Create spark for conjunction: 0x2515630 spark: 0xd + 11200743: cap 0: Start a parallel conjunction 0x2515690, static_id: 2 + 11200918: cap 0: Create spark for conjunction: 0x2515690 spark: 0xe + 11201206: cap 0: Start a parallel conjunction 0x25156f0, static_id: 2 + 11201418: cap 0: Create spark for conjunction: 0x25156f0 spark: 0xf + 11201719: cap 0: Start a parallel conjunction 0x2515750, static_id: 2 + 11201899: cap 0: Create spark for conjunction: 0x2515750 spark: 0x10 + 11202174: cap 0: Start a parallel conjunction 0x25157b0, static_id: 2 + 11220259: cap 0: Create spark for conjunction: 0x25157b0 spark: 0x11 + 11220592: cap 0: Start a parallel conjunction 0x2515810, static_id: 2 + 11220772: cap 0: Create spark for conjunction: 0x2515810 spark: 0x12 + 11221083: cap 0: Start a parallel conjunction 0x2515870, static_id: 2 + 11221272: cap 0: Create spark for conjunction: 0x2515870 spark: 0x13 + 11221533: cap 0: Start a parallel conjunction 0x25158d0, static_id: 2 + 11221731: cap 0: Create spark for conjunction: 0x25158d0 spark: 0x14 + 11222005: cap 0: Start a parallel conjunction 0x2515930, static_id: 2 + 11222199: cap 0: Create spark for conjunction: 0x2515930 spark: 0x15 + 11222478: cap 0: Start a parallel conjunction 0x2515990, static_id: 2 + 11222671: cap 0: Create spark for conjunction: 0x2515990 spark: 0x16 + 11222941: cap 0: Start a parallel conjunction 0x25159f0, static_id: 2 + 11223130: cap 0: Create spark for conjunction: 0x25159f0 spark: 0x17 + 11223400: cap 0: Start a parallel conjunction 0x2515a50, static_id: 2 + 11223580: cap 0: Create spark for conjunction: 0x2515a50 spark: 0x18 + 11223886: cap 0: Start a parallel conjunction 0x2515ab0, static_id: 2 + 11224066: cap 0: Create spark for conjunction: 0x2515ab0 spark: 0x19 + 11224336: cap 0: Start a parallel conjunction 0x2515b10, static_id: 2 + 11224543: cap 0: Create spark for conjunction: 0x2515b10 spark: 0x1a + 11224827: cap 0: Start a parallel conjunction 0x2515b70, static_id: 2 + 11225007: cap 0: Create spark for conjunction: 0x2515b70 spark: 0x1b + 11225286: cap 0: Start a parallel conjunction 0x2515bd0, static_id: 2 + 11225470: cap 0: Create spark for conjunction: 0x2515bd0 spark: 0x1c + 11225758: cap 0: Start a parallel conjunction 0x2515c30, static_id: 2 + 11225956: cap 0: Create spark for conjunction: 0x2515c30 spark: 0x1d + 11226240: cap 0: Start a parallel conjunction 0x2515c90, static_id: 2 + 11226424: cap 0: Create spark for conjunction: 0x2515c90 spark: 0x1e + 11226708: cap 0: Start a parallel conjunction 0x2515cf0, static_id: 2 + 11226892: cap 0: Create spark for conjunction: 0x2515cf0 spark: 0x1f + 11227176: cap 0: Start a parallel conjunction 0x2515d50, static_id: 2 + 11227374: cap 0: Create spark for conjunction: 0x2515d50 spark: 0x20 + 11227653: cap 0: Start a parallel conjunction 0x2515db0, static_id: 2 + 11299891: cap 0: Create spark for conjunction: 0x2515db0 spark: 0x21 + 11300346: cap 0: Start a parallel conjunction 0x2515e10, static_id: 2 + 11300535: cap 0: Create spark for conjunction: 0x2515e10 spark: 0x22 + 11300845: cap 0: Start a parallel conjunction 0x2515e70, static_id: 2 + 11301034: cap 0: Create spark for conjunction: 0x2515e70 spark: 0x23 + 11301291: cap 0: Start a parallel conjunction 0x2515ed0, static_id: 2 + 11301489: cap 0: Create spark for conjunction: 0x2515ed0 spark: 0x24 + 11301772: cap 0: Start a parallel conjunction 0x2515f30, static_id: 2 + 11301961: cap 0: Create spark for conjunction: 0x2515f30 spark: 0x25 + 11302245: cap 0: Start a parallel conjunction 0x2515f90, static_id: 2 + 11302438: cap 0: Create spark for conjunction: 0x2515f90 spark: 0x26 + 11302726: cap 0: Start a parallel conjunction 0x2515ff0, static_id: 2 + 11302929: cap 0: Create spark for conjunction: 0x2515ff0 spark: 0x27 + 11303212: cap 0: Start a parallel conjunction 0x2516050, static_id: 2 + 11303401: cap 0: Create spark for conjunction: 0x2516050 spark: 0x28 + 11303698: cap 0: Start a parallel conjunction 0x25160b0, static_id: 2 + 11303883: cap 0: Create spark for conjunction: 0x25160b0 spark: 0x29 + 11304162: cap 0: Start a parallel conjunction 0x2516110, static_id: 2 + 11304351: cap 0: Create spark for conjunction: 0x2516110 spark: 0x2a + 11304630: cap 0: Start a parallel conjunction 0x2516170, static_id: 2 + 11304814: cap 0: Create spark for conjunction: 0x2516170 spark: 0x2b + 11305093: cap 0: Start a parallel conjunction 0x25161d0, static_id: 2 + 11305287: cap 0: Create spark for conjunction: 0x25161d0 spark: 0x2c + 11305566: cap 0: Start a parallel conjunction 0x2516230, static_id: 2 + 11305759: cap 0: Create spark for conjunction: 0x2516230 spark: 0x2d + 11306034: cap 0: Start a parallel conjunction 0x2516290, static_id: 2 + 11306214: cap 0: Create spark for conjunction: 0x2516290 spark: 0x2e + 11306493: cap 0: Start a parallel conjunction 0x25162f0, static_id: 2 + 11306673: cap 0: Create spark for conjunction: 0x25162f0 spark: 0x2f + 11306943: cap 0: Start a parallel conjunction 0x2516350, static_id: 2 + 11307127: cap 0: Create spark for conjunction: 0x2516350 spark: 0x30 + 11307402: cap 0: Start a parallel conjunction 0x25163b0, static_id: 2 + 11307586: cap 0: Create spark for conjunction: 0x25163b0 spark: 0x31 + 11307852: cap 0: Start a parallel conjunction 0x2516410, static_id: 2 + 11308036: cap 0: Create spark for conjunction: 0x2516410 spark: 0x32 + 11308320: cap 0: Start a parallel conjunction 0x2516470, static_id: 2 + 11308509: cap 0: Create spark for conjunction: 0x2516470 spark: 0x33 + 11308788: cap 0: Start a parallel conjunction 0x25164d0, static_id: 2 + 11308990: cap 0: Create spark for conjunction: 0x25164d0 spark: 0x34 + 11309265: cap 0: Start a parallel conjunction 0x2516530, static_id: 2 + 11309445: cap 0: Create spark for conjunction: 0x2516530 spark: 0x35 + 11309751: cap 0: Start a parallel conjunction 0x2516590, static_id: 2 + 11309931: cap 0: Create spark for conjunction: 0x2516590 spark: 0x36 + 11310196: cap 0: Start a parallel conjunction 0x25165f0, static_id: 2 + 11310394: cap 0: Create spark for conjunction: 0x25165f0 spark: 0x37 + 11310678: cap 0: Start a parallel conjunction 0x2516650, static_id: 2 + 11310867: cap 0: Create spark for conjunction: 0x2516650 spark: 0x38 + 11311155: cap 0: Start a parallel conjunction 0x25166b0, static_id: 2 + 11311339: cap 0: Create spark for conjunction: 0x25166b0 spark: 0x39 + 11311609: cap 0: Start a parallel conjunction 0x2516710, static_id: 2 + 11311794: cap 0: Create spark for conjunction: 0x2516710 spark: 0x3a + 11312073: cap 0: Start a parallel conjunction 0x2516770, static_id: 2 + 11312253: cap 0: Create spark for conjunction: 0x2516770 spark: 0x3b + 11312532: cap 0: Start a parallel conjunction 0x25167d0, static_id: 2 + 11312721: cap 0: Create spark for conjunction: 0x25167d0 spark: 0x3c + 11313000: cap 0: Start a parallel conjunction 0x2516830, static_id: 2 + 11313211: cap 0: Create spark for conjunction: 0x2516830 spark: 0x3d + 11313490: cap 0: Start a parallel conjunction 0x2516890, static_id: 2 + 11313670: cap 0: Create spark for conjunction: 0x2516890 spark: 0x3e + 11313954: cap 0: Start a parallel conjunction 0x25168f0, static_id: 2 + 11314138: cap 0: Create spark for conjunction: 0x25168f0 spark: 0x3f + 11314399: cap 0: Start a parallel conjunction 0x2516950, static_id: 2 + 11314593: cap 0: Create spark for conjunction: 0x2516950 spark: 0x40 + 11314872: cap 0: Start a parallel conjunction 0x25169b0, static_id: 2 + 11358931: cap 0: Create spark for conjunction: 0x25169b0 spark: 0x41 + 11359269: cap 0: Start a parallel conjunction 0x2516a10, static_id: 2 + 11359453: cap 0: Create spark for conjunction: 0x2516a10 spark: 0x42 + 11359755: cap 0: Start a parallel conjunction 0x2516a70, static_id: 2 + 11359948: cap 0: Create spark for conjunction: 0x2516a70 spark: 0x43 + 11360232: cap 0: Start a parallel conjunction 0x2516ad0, static_id: 2 + 11360421: cap 0: Create spark for conjunction: 0x2516ad0 spark: 0x44 + 11360700: cap 0: Start a parallel conjunction 0x2516b30, static_id: 2 + 11360902: cap 0: Create spark for conjunction: 0x2516b30 spark: 0x45 + 11361181: cap 0: Start a parallel conjunction 0x2516b90, static_id: 2 + 11361370: cap 0: Create spark for conjunction: 0x2516b90 spark: 0x46 + 11361645: cap 0: Start a parallel conjunction 0x2516bf0, static_id: 2 + 11361843: cap 0: Create spark for conjunction: 0x2516bf0 spark: 0x47 + 11362117: cap 0: Start a parallel conjunction 0x2516c50, static_id: 2 + 11362302: cap 0: Create spark for conjunction: 0x2516c50 spark: 0x48 + 11362599: cap 0: Start a parallel conjunction 0x2516cb0, static_id: 2 + 11362810: cap 0: Create spark for conjunction: 0x2516cb0 spark: 0x49 + 11363089: cap 0: Start a parallel conjunction 0x2516d10, static_id: 2 + 11363274: cap 0: Create spark for conjunction: 0x2516d10 spark: 0x4a + 11363553: cap 0: Start a parallel conjunction 0x2516d70, static_id: 2 + 11363742: cap 0: Create spark for conjunction: 0x2516d70 spark: 0x4b + 11364021: cap 0: Start a parallel conjunction 0x2516dd0, static_id: 2 + 11364205: cap 0: Create spark for conjunction: 0x2516dd0 spark: 0x4c + 11364480: cap 0: Start a parallel conjunction 0x2516e30, static_id: 2 + 11364682: cap 0: Create spark for conjunction: 0x2516e30 spark: 0x4d + 11364948: cap 0: Start a parallel conjunction 0x2516e90, static_id: 2 + 11365128: cap 0: Create spark for conjunction: 0x2516e90 spark: 0x4e + 11365420: cap 0: Start a parallel conjunction 0x2516ef0, static_id: 2 + 11365609: cap 0: Create spark for conjunction: 0x2516ef0 spark: 0x4f + 11365879: cap 0: Start a parallel conjunction 0x2516f50, static_id: 2 + 11366059: cap 0: Create spark for conjunction: 0x2516f50 spark: 0x50 + 11366338: cap 0: Start a parallel conjunction 0x2516fb0, static_id: 2 + 11366527: cap 0: Create spark for conjunction: 0x2516fb0 spark: 0x51 + 11366833: cap 0: Start a parallel conjunction 0x2517010, static_id: 2 + 11367022: cap 0: Create spark for conjunction: 0x2517010 spark: 0x52 + 11367319: cap 0: Start a parallel conjunction 0x2517070, static_id: 2 + 11367513: cap 0: Create spark for conjunction: 0x2517070 spark: 0x53 + 11367778: cap 0: Start a parallel conjunction 0x25170d0, static_id: 2 + 11367972: cap 0: Create spark for conjunction: 0x25170d0 spark: 0x54 + 11368246: cap 0: Start a parallel conjunction 0x2517130, static_id: 2 + 11368444: cap 0: Create spark for conjunction: 0x2517130 spark: 0x55 + 11368723: cap 0: Start a parallel conjunction 0x2517190, static_id: 2 + 11368908: cap 0: Create spark for conjunction: 0x2517190 spark: 0x56 + 11369182: cap 0: Start a parallel conjunction 0x25171f0, static_id: 2 + 11369385: cap 0: Create spark for conjunction: 0x25171f0 spark: 0x57 + 11369664: cap 0: Start a parallel conjunction 0x2517250, static_id: 2 + 11369853: cap 0: Create spark for conjunction: 0x2517250 spark: 0x58 + 11370136: cap 0: Start a parallel conjunction 0x25172b0, static_id: 2 + 11370334: cap 0: Create spark for conjunction: 0x25172b0 spark: 0x59 + 11370609: cap 0: Start a parallel conjunction 0x2517310, static_id: 2 + 11370811: cap 0: Create spark for conjunction: 0x2517310 spark: 0x5a + 11371090: cap 0: Start a parallel conjunction 0x2517370, static_id: 2 + 11371297: cap 0: Create spark for conjunction: 0x2517370 spark: 0x5b + 11371702: cap 0: Start a parallel conjunction 0x25173d0, static_id: 2 + 11371887: cap 0: Create spark for conjunction: 0x25173d0 spark: 0x5c + 11372152: cap 0: Start a parallel conjunction 0x2517430, static_id: 2 + 11372463: cap 0: Create spark for conjunction: 0x2517430 spark: 0x5d + 11372746: cap 0: Start a parallel conjunction 0x2517490, static_id: 2 + 11372931: cap 0: Create spark for conjunction: 0x2517490 spark: 0x5e + 11373349: cap 0: Start a parallel conjunction 0x25174f0, static_id: 2 + 11373552: cap 0: Create spark for conjunction: 0x25174f0 spark: 0x5f + 11373831: cap 0: Start a parallel conjunction 0x2517550, static_id: 2 + 11374024: cap 0: Create spark for conjunction: 0x2517550 spark: 0x60 + 11374299: cap 0: Start a parallel conjunction 0x25175b0, static_id: 2 + 11374492: cap 0: Create spark for conjunction: 0x25175b0 spark: 0x61 + 11374758: cap 0: Start a parallel conjunction 0x2517610, static_id: 2 + 11374942: cap 0: Create spark for conjunction: 0x2517610 spark: 0x62 + 11375221: cap 0: Start a parallel conjunction 0x2517670, static_id: 2 + 11375415: cap 0: Create spark for conjunction: 0x2517670 spark: 0x63 + 11375671: cap 0: Start a parallel conjunction 0x25176d0, static_id: 2 + 11375865: cap 0: Create spark for conjunction: 0x25176d0 spark: 0x64 + 11376148: cap 0: Start a parallel conjunction 0x2517730, static_id: 2 + 11376342: cap 0: Create spark for conjunction: 0x2517730 spark: 0x65 + 11376616: cap 0: Start a parallel conjunction 0x2517790, static_id: 2 + 11376805: cap 0: Create spark for conjunction: 0x2517790 spark: 0x66 + 11377062: cap 0: Start a parallel conjunction 0x25177f0, static_id: 2 + 11377264: cap 0: Create spark for conjunction: 0x25177f0 spark: 0x67 + 11377539: cap 0: Start a parallel conjunction 0x2517850, static_id: 2 + 11377723: cap 0: Create spark for conjunction: 0x2517850 spark: 0x68 + 11378007: cap 0: Start a parallel conjunction 0x25178b0, static_id: 2 + 11378205: cap 0: Create spark for conjunction: 0x25178b0 spark: 0x69 + 11378484: cap 0: Start a parallel conjunction 0x2517910, static_id: 2 + 11378677: cap 0: Create spark for conjunction: 0x2517910 spark: 0x6a + 11378965: cap 0: Start a parallel conjunction 0x2517970, static_id: 2 + 11379168: cap 0: Create spark for conjunction: 0x2517970 spark: 0x6b + 11379465: cap 0: Start a parallel conjunction 0x25179d0, static_id: 2 + 11379649: cap 0: Create spark for conjunction: 0x25179d0 spark: 0x6c + 11379915: cap 0: Start a parallel conjunction 0x2517a30, static_id: 2 + 11380117: cap 0: Create spark for conjunction: 0x2517a30 spark: 0x6d + 11380378: cap 0: Start a parallel conjunction 0x2517a90, static_id: 2 + 11380558: cap 0: Create spark for conjunction: 0x2517a90 spark: 0x6e + 11380837: cap 0: Start a parallel conjunction 0x2517af0, static_id: 2 + 11381040: cap 0: Create spark for conjunction: 0x2517af0 spark: 0x6f + 11381296: cap 0: Start a parallel conjunction 0x2517b50, static_id: 2 + 11381481: cap 0: Create spark for conjunction: 0x2517b50 spark: 0x70 + 11381751: cap 0: Start a parallel conjunction 0x2517bb0, static_id: 2 + 11381953: cap 0: Create spark for conjunction: 0x2517bb0 spark: 0x71 + 11382219: cap 0: Start a parallel conjunction 0x2517c10, static_id: 2 + 11382412: cap 0: Create spark for conjunction: 0x2517c10 spark: 0x72 + 11382700: cap 0: Start a parallel conjunction 0x2517c70, static_id: 2 + 11382912: cap 0: Create spark for conjunction: 0x2517c70 spark: 0x73 + 11383195: cap 0: Start a parallel conjunction 0x2517cd0, static_id: 2 + 11383402: cap 0: Create spark for conjunction: 0x2517cd0 spark: 0x74 + 11383672: cap 0: Start a parallel conjunction 0x2517d30, static_id: 2 + 11383875: cap 0: Create spark for conjunction: 0x2517d30 spark: 0x75 + 11384163: cap 0: Start a parallel conjunction 0x2517d90, static_id: 2 + 11384352: cap 0: Create spark for conjunction: 0x2517d90 spark: 0x76 + 11384622: cap 0: Start a parallel conjunction 0x2517df0, static_id: 2 + 11384824: cap 0: Create spark for conjunction: 0x2517df0 spark: 0x77 + 11385099: cap 0: Start a parallel conjunction 0x2517e50, static_id: 2 + 11385288: cap 0: Create spark for conjunction: 0x2517e50 spark: 0x78 + 11385567: cap 0: Start a parallel conjunction 0x2517eb0, static_id: 2 + 11385765: cap 0: Create spark for conjunction: 0x2517eb0 spark: 0x79 + 11386021: cap 0: Start a parallel conjunction 0x2517f10, static_id: 2 + 11386210: cap 0: Create spark for conjunction: 0x2517f10 spark: 0x7a + 11386480: cap 0: Start a parallel conjunction 0x2517f70, static_id: 2 + 11386674: cap 0: Create spark for conjunction: 0x2517f70 spark: 0x7b + 11386971: cap 0: Start a parallel conjunction 0x2517fd0, static_id: 2 + 11387160: cap 0: Create spark for conjunction: 0x2517fd0 spark: 0x7c + 11387475: cap 0: Start a parallel conjunction 0x2518030, static_id: 2 + 11387695: cap 0: Create spark for conjunction: 0x2518030 spark: 0x7d + 11388001: cap 0: Start a parallel conjunction 0x2518090, static_id: 2 + 11388190: cap 0: Create spark for conjunction: 0x2518090 spark: 0x7e + 11388496: cap 0: Start a parallel conjunction 0x25180f0, static_id: 2 + 11388699: cap 0: Create spark for conjunction: 0x25180f0 spark: 0x7f + 11388960: cap 0: Start a parallel conjunction 0x2518150, static_id: 2 + 11389144: cap 0: Create spark for conjunction: 0x2518150 spark: 0x80 + 11389423: cap 0: Start a parallel conjunction 0x25181b0, static_id: 2 + 11409403: cap 0: Create spark for conjunction: 0x25181b0 spark: 0x81 + 11409732: cap 0: Start a parallel conjunction 0x2518210, static_id: 2 + 11409930: cap 0: Create spark for conjunction: 0x2518210 spark: 0x82 + 11410236: cap 0: Start a parallel conjunction 0x2518270, static_id: 2 + 11410425: cap 0: Create spark for conjunction: 0x2518270 spark: 0x83 + 11410699: cap 0: Start a parallel conjunction 0x25182d0, static_id: 2 + 11410947: cap 0: Create spark for conjunction: 0x25182d0 spark: 0x84 + 11411226: cap 0: Start a parallel conjunction 0x2518330, static_id: 2 + 11411406: cap 0: Create spark for conjunction: 0x2518330 spark: 0x85 + 11411694: cap 0: Start a parallel conjunction 0x2518390, static_id: 2 + 11411874: cap 0: Create spark for conjunction: 0x2518390 spark: 0x86 + 11412135: cap 0: Start a parallel conjunction 0x25183f0, static_id: 2 + 11412337: cap 0: Create spark for conjunction: 0x25183f0 spark: 0x87 + 11412621: cap 0: Start a parallel conjunction 0x2518450, static_id: 2 + 11412868: cap 0: Create spark for conjunction: 0x2518450 spark: 0x88 + 11413170: cap 0: Start a parallel conjunction 0x25184b0, static_id: 2 + 11413363: cap 0: Create spark for conjunction: 0x25184b0 spark: 0x89 + 11413638: cap 0: Start a parallel conjunction 0x2518510, static_id: 2 + 11413822: cap 0: Create spark for conjunction: 0x2518510 spark: 0x8a + 11414218: cap 0: Start a parallel conjunction 0x2518570, static_id: 2 + 11414461: cap 0: Create spark for conjunction: 0x2518570 spark: 0x8b + 11414758: cap 0: Start a parallel conjunction 0x25185d0, static_id: 2 + 11414938: cap 0: Create spark for conjunction: 0x25185d0 spark: 0x8c + 11415213: cap 0: Start a parallel conjunction 0x2518630, static_id: 2 + 11415415: cap 0: Create spark for conjunction: 0x2518630 spark: 0x8d + 11415685: cap 0: Start a parallel conjunction 0x2518690, static_id: 2 + 11415865: cap 0: Create spark for conjunction: 0x2518690 spark: 0x8e + 11416149: cap 0: Start a parallel conjunction 0x25186f0, static_id: 2 + 11416333: cap 0: Create spark for conjunction: 0x25186f0 spark: 0x8f + 11416603: cap 0: Start a parallel conjunction 0x2518750, static_id: 2 + 11416788: cap 0: Create spark for conjunction: 0x2518750 spark: 0x90 + 11417067: cap 0: Start a parallel conjunction 0x25187b0, static_id: 2 + 11417256: cap 0: Create spark for conjunction: 0x25187b0 spark: 0x91 + 11417530: cap 0: Start a parallel conjunction 0x2518810, static_id: 2 + 11417715: cap 0: Create spark for conjunction: 0x2518810 spark: 0x92 + 11418012: cap 0: Start a parallel conjunction 0x2518870, static_id: 2 + 11418205: cap 0: Create spark for conjunction: 0x2518870 spark: 0x93 + 11418471: cap 0: Start a parallel conjunction 0x25188d0, static_id: 2 + 11418669: cap 0: Create spark for conjunction: 0x25188d0 spark: 0x94 + 11418961: cap 0: Start a parallel conjunction 0x2518930, static_id: 2 + 11419150: cap 0: Create spark for conjunction: 0x2518930 spark: 0x95 + 11419434: cap 0: Start a parallel conjunction 0x2518990, static_id: 2 + 11419618: cap 0: Create spark for conjunction: 0x2518990 spark: 0x96 + 11419879: cap 0: Start a parallel conjunction 0x25189f0, static_id: 2 + 11420077: cap 0: Create spark for conjunction: 0x25189f0 spark: 0x97 + 11420352: cap 0: Start a parallel conjunction 0x2518a50, static_id: 2 + 11420536: cap 0: Create spark for conjunction: 0x2518a50 spark: 0x98 + 11420838: cap 0: Start a parallel conjunction 0x2518ab0, static_id: 2 + 11421036: cap 0: Create spark for conjunction: 0x2518ab0 spark: 0x99 + 11421315: cap 0: Start a parallel conjunction 0x2518b10, static_id: 2 + 11421513: cap 0: Create spark for conjunction: 0x2518b10 spark: 0x9a + 11421792: cap 0: Start a parallel conjunction 0x2518b70, static_id: 2 + 11421985: cap 0: Create spark for conjunction: 0x2518b70 spark: 0x9b + 11422264: cap 0: Start a parallel conjunction 0x2518bd0, static_id: 2 + 11422449: cap 0: Create spark for conjunction: 0x2518bd0 spark: 0x9c + 11422737: cap 0: Start a parallel conjunction 0x2518c30, static_id: 2 + 11422939: cap 0: Create spark for conjunction: 0x2518c30 spark: 0x9d + 11423209: cap 0: Start a parallel conjunction 0x2518c90, static_id: 2 + 11423403: cap 0: Create spark for conjunction: 0x2518c90 spark: 0x9e + 11423686: cap 0: Start a parallel conjunction 0x2518cf0, static_id: 2 + 11423871: cap 0: Create spark for conjunction: 0x2518cf0 spark: 0x9f + 11424136: cap 0: Start a parallel conjunction 0x2518d50, static_id: 2 + 11424316: cap 0: Create spark for conjunction: 0x2518d50 spark: 0xa0 + 11424586: cap 0: Start a parallel conjunction 0x2518db0, static_id: 2 + 11424780: cap 0: Create spark for conjunction: 0x2518db0 spark: 0xa1 + 11425050: cap 0: Start a parallel conjunction 0x2518e10, static_id: 2 + 11425234: cap 0: Create spark for conjunction: 0x2518e10 spark: 0xa2 + 11425536: cap 0: Start a parallel conjunction 0x2518e70, static_id: 2 + 11425725: cap 0: Create spark for conjunction: 0x2518e70 spark: 0xa3 + 11425995: cap 0: Start a parallel conjunction 0x2518ed0, static_id: 2 + 11426184: cap 0: Create spark for conjunction: 0x2518ed0 spark: 0xa4 + 11426458: cap 0: Start a parallel conjunction 0x2518f30, static_id: 2 + 11426643: cap 0: Create spark for conjunction: 0x2518f30 spark: 0xa5 + 11426935: cap 0: Start a parallel conjunction 0x2518f90, static_id: 2 + 11427151: cap 0: Create spark for conjunction: 0x2518f90 spark: 0xa6 + 11427466: cap 0: Start a parallel conjunction 0x2518ff0, static_id: 2 + 11427673: cap 0: Create spark for conjunction: 0x2518ff0 spark: 0xa7 + 11427952: cap 0: Start a parallel conjunction 0x2519050, static_id: 2 + 11428141: cap 0: Create spark for conjunction: 0x2519050 spark: 0xa8 + 11428429: cap 0: Start a parallel conjunction 0x25190b0, static_id: 2 + 11428609: cap 0: Create spark for conjunction: 0x25190b0 spark: 0xa9 + 11428875: cap 0: Start a parallel conjunction 0x2519110, static_id: 2 + 11429064: cap 0: Create spark for conjunction: 0x2519110 spark: 0xaa + 11429365: cap 0: Start a parallel conjunction 0x2519170, static_id: 2 + 11429554: cap 0: Create spark for conjunction: 0x2519170 spark: 0xab + 11429842: cap 0: Start a parallel conjunction 0x25191d0, static_id: 2 + 11430036: cap 0: Create spark for conjunction: 0x25191d0 spark: 0xac + 11430310: cap 0: Start a parallel conjunction 0x2519230, static_id: 2 + 11430504: cap 0: Create spark for conjunction: 0x2519230 spark: 0xad + 11430774: cap 0: Start a parallel conjunction 0x2519290, static_id: 2 + 11430954: cap 0: Create spark for conjunction: 0x2519290 spark: 0xae + 11431246: cap 0: Start a parallel conjunction 0x25192f0, static_id: 2 + 11431431: cap 0: Create spark for conjunction: 0x25192f0 spark: 0xaf + 11431696: cap 0: Start a parallel conjunction 0x2519350, static_id: 2 + 11431885: cap 0: Create spark for conjunction: 0x2519350 spark: 0xb0 + 11432164: cap 0: Start a parallel conjunction 0x25193b0, static_id: 2 + 11432358: cap 0: Create spark for conjunction: 0x25193b0 spark: 0xb1 + 11432632: cap 0: Start a parallel conjunction 0x2519410, static_id: 2 + 11432821: cap 0: Create spark for conjunction: 0x2519410 spark: 0xb2 + 11433213: cap 0: Start a parallel conjunction 0x2519470, static_id: 2 + 11433406: cap 0: Create spark for conjunction: 0x2519470 spark: 0xb3 + 11433681: cap 0: Start a parallel conjunction 0x25194d0, static_id: 2 + 11433892: cap 0: Create spark for conjunction: 0x25194d0 spark: 0xb4 + 11434185: cap 0: Start a parallel conjunction 0x2519530, static_id: 2 + 11434378: cap 0: Create spark for conjunction: 0x2519530 spark: 0xb5 + 11434657: cap 0: Start a parallel conjunction 0x2519590, static_id: 2 + 11434842: cap 0: Create spark for conjunction: 0x2519590 spark: 0xb6 + 11435107: cap 0: Start a parallel conjunction 0x25195f0, static_id: 2 + 11435323: cap 0: Create spark for conjunction: 0x25195f0 spark: 0xb7 + 11435611: cap 0: Start a parallel conjunction 0x2519650, static_id: 2 + 11435805: cap 0: Create spark for conjunction: 0x2519650 spark: 0xb8 + 11436237: cap 0: Start a parallel conjunction 0x25196b0, static_id: 2 + 11436421: cap 0: Create spark for conjunction: 0x25196b0 spark: 0xb9 + 11436682: cap 0: Start a parallel conjunction 0x2519710, static_id: 2 + 11436979: cap 0: Create spark for conjunction: 0x2519710 spark: 0xba + 11437285: cap 0: Start a parallel conjunction 0x2519770, static_id: 2 + 11437488: cap 0: Create spark for conjunction: 0x2519770 spark: 0xbb + 11437834: cap 0: Start a parallel conjunction 0x25197d0, static_id: 2 + 11438028: cap 0: Create spark for conjunction: 0x25197d0 spark: 0xbc + 11438311: cap 0: Start a parallel conjunction 0x2519830, static_id: 2 + 11438500: cap 0: Create spark for conjunction: 0x2519830 spark: 0xbd + 11438770: cap 0: Start a parallel conjunction 0x2519890, static_id: 2 + 11438959: cap 0: Create spark for conjunction: 0x2519890 spark: 0xbe + 11439243: cap 0: Start a parallel conjunction 0x25198f0, static_id: 2 + 11439432: cap 0: Create spark for conjunction: 0x25198f0 spark: 0xbf + 11439693: cap 0: Start a parallel conjunction 0x2519950, static_id: 2 + 11439886: cap 0: Create spark for conjunction: 0x2519950 spark: 0xc0 + 11440170: cap 0: Start a parallel conjunction 0x25199b0, static_id: 2 + 11440363: cap 0: Create spark for conjunction: 0x25199b0 spark: 0xc1 + 11440633: cap 0: Start a parallel conjunction 0x2519a10, static_id: 2 + 11440818: cap 0: Create spark for conjunction: 0x2519a10 spark: 0xc2 + 11441097: cap 0: Start a parallel conjunction 0x2519a70, static_id: 2 + 11441290: cap 0: Create spark for conjunction: 0x2519a70 spark: 0xc3 + 11441560: cap 0: Start a parallel conjunction 0x2519ad0, static_id: 2 + 11441749: cap 0: Create spark for conjunction: 0x2519ad0 spark: 0xc4 + 11442037: cap 0: Start a parallel conjunction 0x2519b30, static_id: 2 + 11442235: cap 0: Create spark for conjunction: 0x2519b30 spark: 0xc5 + 11442514: cap 0: Start a parallel conjunction 0x2519b90, static_id: 2 + 11442699: cap 0: Create spark for conjunction: 0x2519b90 spark: 0xc6 + 11442964: cap 0: Start a parallel conjunction 0x2519bf0, static_id: 2 + 11443167: cap 0: Create spark for conjunction: 0x2519bf0 spark: 0xc7 + 11443446: cap 0: Start a parallel conjunction 0x2519c50, static_id: 2 + 11443635: cap 0: Create spark for conjunction: 0x2519c50 spark: 0xc8 + 11444053: cap 0: Start a parallel conjunction 0x2519cb0, static_id: 2 + 11444251: cap 0: Create spark for conjunction: 0x2519cb0 spark: 0xc9 + 11444517: cap 0: Start a parallel conjunction 0x2519d10, static_id: 2 + 11444701: cap 0: Create spark for conjunction: 0x2519d10 spark: 0xca + 11444971: cap 0: Start a parallel conjunction 0x2519d70, static_id: 2 + 11445165: cap 0: Create spark for conjunction: 0x2519d70 spark: 0xcb + 11445453: cap 0: Start a parallel conjunction 0x2519dd0, static_id: 2 + 11445637: cap 0: Create spark for conjunction: 0x2519dd0 spark: 0xcc + 11445912: cap 0: Start a parallel conjunction 0x2519e30, static_id: 2 + 11446101: cap 0: Create spark for conjunction: 0x2519e30 spark: 0xcd + 11446380: cap 0: Start a parallel conjunction 0x2519e90, static_id: 2 + 11446564: cap 0: Create spark for conjunction: 0x2519e90 spark: 0xce + 11446848: cap 0: Start a parallel conjunction 0x2519ef0, static_id: 2 + 11447041: cap 0: Create spark for conjunction: 0x2519ef0 spark: 0xcf + 11447316: cap 0: Start a parallel conjunction 0x2519f50, static_id: 2 + 11447505: cap 0: Create spark for conjunction: 0x2519f50 spark: 0xd0 + 11447793: cap 0: Start a parallel conjunction 0x2519fb0, static_id: 2 + 11447991: cap 0: Create spark for conjunction: 0x2519fb0 spark: 0xd1 + 11448544: cap 0: Start a parallel conjunction 0x251a010, static_id: 2 + 11448729: cap 0: Create spark for conjunction: 0x251a010 spark: 0xd2 + 11449026: cap 0: Start a parallel conjunction 0x251a070, static_id: 2 + 11449206: cap 0: Create spark for conjunction: 0x251a070 spark: 0xd3 + 11449480: cap 0: Start a parallel conjunction 0x251a0d0, static_id: 2 + 11449678: cap 0: Create spark for conjunction: 0x251a0d0 spark: 0xd4 + 11449957: cap 0: Start a parallel conjunction 0x251a130, static_id: 2 + 11450155: cap 0: Create spark for conjunction: 0x251a130 spark: 0xd5 + 11450443: cap 0: Start a parallel conjunction 0x251a190, static_id: 2 + 11450623: cap 0: Create spark for conjunction: 0x251a190 spark: 0xd6 + 11450884: cap 0: Start a parallel conjunction 0x251a1f0, static_id: 2 + 11451087: cap 0: Create spark for conjunction: 0x251a1f0 spark: 0xd7 + 11451370: cap 0: Start a parallel conjunction 0x251a250, static_id: 2 + 11451555: cap 0: Create spark for conjunction: 0x251a250 spark: 0xd8 + 11451852: cap 0: Start a parallel conjunction 0x251a2b0, static_id: 2 + 11452041: cap 0: Create spark for conjunction: 0x251a2b0 spark: 0xd9 + 11452311: cap 0: Start a parallel conjunction 0x251a310, static_id: 2 + 11452500: cap 0: Create spark for conjunction: 0x251a310 spark: 0xda + 11452779: cap 0: Start a parallel conjunction 0x251a370, static_id: 2 + 11452968: cap 0: Create spark for conjunction: 0x251a370 spark: 0xdb + 11453247: cap 0: Start a parallel conjunction 0x251a3d0, static_id: 2 + 11453427: cap 0: Create spark for conjunction: 0x251a3d0 spark: 0xdc + 11453701: cap 0: Start a parallel conjunction 0x251a430, static_id: 2 + 11453904: cap 0: Create spark for conjunction: 0x251a430 spark: 0xdd + 11454174: cap 0: Start a parallel conjunction 0x251a490, static_id: 2 + 11454354: cap 0: Create spark for conjunction: 0x251a490 spark: 0xde + 11454637: cap 0: Start a parallel conjunction 0x251a4f0, static_id: 2 + 11454826: cap 0: Create spark for conjunction: 0x251a4f0 spark: 0xdf + 11455092: cap 0: Start a parallel conjunction 0x251a550, static_id: 2 + 11455272: cap 0: Create spark for conjunction: 0x251a550 spark: 0xe0 + 11455546: cap 0: Start a parallel conjunction 0x251a5b0, static_id: 2 + 11455731: cap 0: Create spark for conjunction: 0x251a5b0 spark: 0xe1 + 11456014: cap 0: Start a parallel conjunction 0x251a610, static_id: 2 + 11456199: cap 0: Create spark for conjunction: 0x251a610 spark: 0xe2 + 11456487: cap 0: Start a parallel conjunction 0x251a670, static_id: 2 + 11456676: cap 0: Create spark for conjunction: 0x251a670 spark: 0xe3 + 11456946: cap 0: Start a parallel conjunction 0x251a6d0, static_id: 2 + 11457148: cap 0: Create spark for conjunction: 0x251a6d0 spark: 0xe4 + 11457445: cap 0: Start a parallel conjunction 0x251a730, static_id: 2 + 11457639: cap 0: Create spark for conjunction: 0x251a730 spark: 0xe5 + 11457927: cap 0: Start a parallel conjunction 0x251a790, static_id: 2 + 11458107: cap 0: Create spark for conjunction: 0x251a790 spark: 0xe6 + 11458372: cap 0: Start a parallel conjunction 0x251a7f0, static_id: 2 + 11458566: cap 0: Create spark for conjunction: 0x251a7f0 spark: 0xe7 + 11458836: cap 0: Start a parallel conjunction 0x251a850, static_id: 2 + 11459020: cap 0: Create spark for conjunction: 0x251a850 spark: 0xe8 + 11459299: cap 0: Start a parallel conjunction 0x251a8b0, static_id: 2 + 11459493: cap 0: Create spark for conjunction: 0x251a8b0 spark: 0xe9 + 11459758: cap 0: Start a parallel conjunction 0x251a910, static_id: 2 + 11466868: cap 0: Create spark for conjunction: 0x251a910 spark: 0xea + 11467057: cap 0: Start a parallel conjunction 0x251a970, static_id: 2 + 11467179: cap 0: Create spark for conjunction: 0x251a970 spark: 0xeb + 11467372: cap 0: Start a parallel conjunction 0x251a9d0, static_id: 2 + 11467494: cap 0: Create spark for conjunction: 0x251a9d0 spark: 0xec + 11467683: cap 0: Start a parallel conjunction 0x251aa30, static_id: 2 + 11467809: cap 0: Create spark for conjunction: 0x251aa30 spark: 0xed + 11467993: cap 0: Start a parallel conjunction 0x251aa90, static_id: 2 + 11468115: cap 0: Create spark for conjunction: 0x251aa90 spark: 0xee + 11468304: cap 0: Start a parallel conjunction 0x251aaf0, static_id: 2 + 11468434: cap 0: Create spark for conjunction: 0x251aaf0 spark: 0xef + 11468619: cap 0: Start a parallel conjunction 0x251ab50, static_id: 2 + 11468740: cap 0: Create spark for conjunction: 0x251ab50 spark: 0xf0 + 11468920: cap 0: Start a parallel conjunction 0x251abb0, static_id: 2 + 11469046: cap 0: Create spark for conjunction: 0x251abb0 spark: 0xf1 + 11469226: cap 0: Start a parallel conjunction 0x251ac10, static_id: 2 + 11469348: cap 0: Create spark for conjunction: 0x251ac10 spark: 0xf2 + 11469532: cap 0: Start a parallel conjunction 0x251ac70, static_id: 2 + 11469658: cap 0: Create spark for conjunction: 0x251ac70 spark: 0xf3 + 11469834: cap 0: Start a parallel conjunction 0x251acd0, static_id: 2 + 11469960: cap 0: Create spark for conjunction: 0x251acd0 spark: 0xf4 + 11470144: cap 0: Start a parallel conjunction 0x251ad30, static_id: 2 + 11470270: cap 0: Create spark for conjunction: 0x251ad30 spark: 0xf5 + 11470464: cap 0: Start a parallel conjunction 0x251ad90, static_id: 2 + 11470585: cap 0: Create spark for conjunction: 0x251ad90 spark: 0xf6 + 11470761: cap 0: Start a parallel conjunction 0x251adf0, static_id: 2 + 11470887: cap 0: Create spark for conjunction: 0x251adf0 spark: 0xf7 + 11471071: cap 0: Start a parallel conjunction 0x251ae50, static_id: 2 + 11471193: cap 0: Create spark for conjunction: 0x251ae50 spark: 0xf8 + 11471391: cap 0: Start a parallel conjunction 0x251aeb0, static_id: 2 + 11471512: cap 0: Create spark for conjunction: 0x251aeb0 spark: 0xf9 + 11471692: cap 0: Start a parallel conjunction 0x251af10, static_id: 2 + 11471818: cap 0: Create spark for conjunction: 0x251af10 spark: 0xfa + 11472223: cap 0: Start a parallel conjunction 0x251af70, static_id: 2 + 11472349: cap 0: Create spark for conjunction: 0x251af70 spark: 0xfb + 11472718: cap 0: Start a parallel conjunction 0x251afd0, static_id: 2 + 11472844: cap 0: Create spark for conjunction: 0x251afd0 spark: 0xfc + 11473209: cap 0: Start a parallel conjunction 0x251b030, static_id: 2 + 11473339: cap 0: Create spark for conjunction: 0x251b030 spark: 0xfd + 11473524: cap 0: Start a parallel conjunction 0x251b090, static_id: 2 + 11473645: cap 0: Create spark for conjunction: 0x251b090 spark: 0xfe + 11473834: cap 0: Start a parallel conjunction 0x251b0f0, static_id: 2 + 11473956: cap 0: Create spark for conjunction: 0x251b0f0 spark: 0xff + 11474136: cap 0: Start a parallel conjunction 0x251b150, static_id: 2 + 11474257: cap 0: Create spark for conjunction: 0x251b150 spark: 0x100 + 11474446: cap 0: Start a parallel conjunction 0x251b1b0, static_id: 2 + 11497689: cap 0: Create spark for conjunction: 0x251b1b0 spark: 0x101 + 11497918: cap 0: Start a parallel conjunction 0x251b210, static_id: 2 + 11498053: cap 0: Create spark for conjunction: 0x251b210 spark: 0x102 + 11498256: cap 0: Start a parallel conjunction 0x251b270, static_id: 2 + 11498391: cap 0: Create spark for conjunction: 0x251b270 spark: 0x103 + 11498566: cap 0: Start a parallel conjunction 0x251b2d0, static_id: 2 + 11498742: cap 0: Create spark for conjunction: 0x251b2d0 spark: 0x104 + 11498926: cap 0: Start a parallel conjunction 0x251b330, static_id: 2 + 11499057: cap 0: Create spark for conjunction: 0x251b330 spark: 0x105 + 11499246: cap 0: Start a parallel conjunction 0x251b390, static_id: 2 + 11499372: cap 0: Create spark for conjunction: 0x251b390 spark: 0x106 + 11499561: cap 0: Start a parallel conjunction 0x251b3f0, static_id: 2 + 11499696: cap 0: Create spark for conjunction: 0x251b3f0 spark: 0x107 + 11499876: cap 0: Start a parallel conjunction 0x251b450, static_id: 2 + 11500042: cap 0: Create spark for conjunction: 0x251b450 spark: 0x108 + 11500245: cap 0: Start a parallel conjunction 0x251b4b0, static_id: 2 + 11500375: cap 0: Create spark for conjunction: 0x251b4b0 spark: 0x109 + 11500555: cap 0: Start a parallel conjunction 0x251b510, static_id: 2 + 11500681: cap 0: Create spark for conjunction: 0x251b510 spark: 0x10a + 11500866: cap 0: Start a parallel conjunction 0x251b570, static_id: 2 + 11500987: cap 0: Create spark for conjunction: 0x251b570 spark: 0x10b + 11501176: cap 0: Start a parallel conjunction 0x251b5d0, static_id: 2 + 11501307: cap 0: Create spark for conjunction: 0x251b5d0 spark: 0x10c + 11501496: cap 0: Start a parallel conjunction 0x251b630, static_id: 2 + 11501631: cap 0: Create spark for conjunction: 0x251b630 spark: 0x10d + 11501815: cap 0: Start a parallel conjunction 0x251b690, static_id: 2 + 11501937: cap 0: Create spark for conjunction: 0x251b690 spark: 0x10e + 11502135: cap 0: Start a parallel conjunction 0x251b6f0, static_id: 2 + 11502274: cap 0: Create spark for conjunction: 0x251b6f0 spark: 0x10f + 11502445: cap 0: Start a parallel conjunction 0x251b750, static_id: 2 + 11502567: cap 0: Create spark for conjunction: 0x251b750 spark: 0x110 + 11502769: cap 0: Start a parallel conjunction 0x251b7b0, static_id: 2 + 11502895: cap 0: Create spark for conjunction: 0x251b7b0 spark: 0x111 + 11503075: cap 0: Start a parallel conjunction 0x251b810, static_id: 2 + 11503192: cap 0: Create spark for conjunction: 0x251b810 spark: 0x112 + 11503377: cap 0: Start a parallel conjunction 0x251b870, static_id: 2 + 11503507: cap 0: Create spark for conjunction: 0x251b870 spark: 0x113 + 11503687: cap 0: Start a parallel conjunction 0x251b8d0, static_id: 2 + 11503818: cap 0: Create spark for conjunction: 0x251b8d0 spark: 0x114 + 11504007: cap 0: Start a parallel conjunction 0x251b930, static_id: 2 + 11504137: cap 0: Create spark for conjunction: 0x251b930 spark: 0x115 + 11504470: cap 0: Start a parallel conjunction 0x251b990, static_id: 2 + 11504592: cap 0: Create spark for conjunction: 0x251b990 spark: 0x116 + 11504790: cap 0: Start a parallel conjunction 0x251b9f0, static_id: 2 + 11505217: cap 0: Create spark for conjunction: 0x251b9f0 spark: 0x117 + 11505402: cap 0: Start a parallel conjunction 0x251ba50, static_id: 2 + 11505523: cap 0: Create spark for conjunction: 0x251ba50 spark: 0x118 + 11505721: cap 0: Start a parallel conjunction 0x251bab0, static_id: 2 + 11505852: cap 0: Create spark for conjunction: 0x251bab0 spark: 0x119 + 11506041: cap 0: Start a parallel conjunction 0x251bb10, static_id: 2 + 11506167: cap 0: Create spark for conjunction: 0x251bb10 spark: 0x11a + 11506369: cap 0: Start a parallel conjunction 0x251bb70, static_id: 2 + 11506500: cap 0: Create spark for conjunction: 0x251bb70 spark: 0x11b + 11506689: cap 0: Start a parallel conjunction 0x251bbd0, static_id: 2 + 11506810: cap 0: Create spark for conjunction: 0x251bbd0 spark: 0x11c + 11506990: cap 0: Start a parallel conjunction 0x251bc30, static_id: 2 + 11507130: cap 0: Create spark for conjunction: 0x251bc30 spark: 0x11d + 11507310: cap 0: Start a parallel conjunction 0x251bc90, static_id: 2 + 11507431: cap 0: Create spark for conjunction: 0x251bc90 spark: 0x11e + 11507620: cap 0: Start a parallel conjunction 0x251bcf0, static_id: 2 + 11507751: cap 0: Create spark for conjunction: 0x251bcf0 spark: 0x11f + 11507926: cap 0: Start a parallel conjunction 0x251bd50, static_id: 2 + 11508052: cap 0: Create spark for conjunction: 0x251bd50 spark: 0x120 + 11508237: cap 0: Start a parallel conjunction 0x251bdb0, static_id: 2 + 11508363: cap 0: Create spark for conjunction: 0x251bdb0 spark: 0x121 + 11508556: cap 0: Start a parallel conjunction 0x251be10, static_id: 2 + 11508682: cap 0: Create spark for conjunction: 0x251be10 spark: 0x122 + 11508889: cap 0: Start a parallel conjunction 0x251be70, static_id: 2 + 11509020: cap 0: Create spark for conjunction: 0x251be70 spark: 0x123 + 11509200: cap 0: Start a parallel conjunction 0x251bed0, static_id: 2 + 11509326: cap 0: Create spark for conjunction: 0x251bed0 spark: 0x124 + 11509510: cap 0: Start a parallel conjunction 0x251bf30, static_id: 2 + 11509636: cap 0: Create spark for conjunction: 0x251bf30 spark: 0x125 + 11509929: cap 0: Start a parallel conjunction 0x251bf90, static_id: 2 + 11510050: cap 0: Create spark for conjunction: 0x251bf90 spark: 0x126 + 11510361: cap 0: Start a parallel conjunction 0x251bff0, static_id: 2 + 11510496: cap 0: Create spark for conjunction: 0x251bff0 spark: 0x127 + 11510685: cap 0: Start a parallel conjunction 0x251c050, static_id: 2 + 11510811: cap 0: Create spark for conjunction: 0x251c050 spark: 0x128 + 11511000: cap 0: Start a parallel conjunction 0x251c0b0, static_id: 2 + 11511126: cap 0: Create spark for conjunction: 0x251c0b0 spark: 0x129 + 11511301: cap 0: Start a parallel conjunction 0x251c110, static_id: 2 + 11511427: cap 0: Create spark for conjunction: 0x251c110 spark: 0x12a + 11511612: cap 0: Start a parallel conjunction 0x251c170, static_id: 2 + 11511733: cap 0: Create spark for conjunction: 0x251c170 spark: 0x12b + 11511918: cap 0: Start a parallel conjunction 0x251c1d0, static_id: 2 + 11512039: cap 0: Create spark for conjunction: 0x251c1d0 spark: 0x12c + 11512219: cap 0: Start a parallel conjunction 0x251c230, static_id: 2 + 11512345: cap 0: Create spark for conjunction: 0x251c230 spark: 0x12d + 11512530: cap 0: Start a parallel conjunction 0x251c290, static_id: 2 + 11512647: cap 0: Create spark for conjunction: 0x251c290 spark: 0x12e + 11512939: cap 0: Start a parallel conjunction 0x251c2f0, static_id: 2 + 11513061: cap 0: Create spark for conjunction: 0x251c2f0 spark: 0x12f + 11513232: cap 0: Start a parallel conjunction 0x251c350, static_id: 2 + 11513353: cap 0: Create spark for conjunction: 0x251c350 spark: 0x130 + 11513538: cap 0: Start a parallel conjunction 0x251c3b0, static_id: 2 + 11513664: cap 0: Create spark for conjunction: 0x251c3b0 spark: 0x131 + 11513839: cap 0: Start a parallel conjunction 0x251c410, static_id: 2 + 11513961: cap 0: Create spark for conjunction: 0x251c410 spark: 0x132 + 11514267: cap 0: Start a parallel conjunction 0x251c470, static_id: 2 + 11514397: cap 0: Create spark for conjunction: 0x251c470 spark: 0x133 + 11514568: cap 0: Start a parallel conjunction 0x251c4d0, static_id: 2 + 11514699: cap 0: Create spark for conjunction: 0x251c4d0 spark: 0x134 + 11514892: cap 0: Start a parallel conjunction 0x251c530, static_id: 2 + 11515027: cap 0: Create spark for conjunction: 0x251c530 spark: 0x135 + 11515225: cap 0: Start a parallel conjunction 0x251c590, static_id: 2 + 11515351: cap 0: Create spark for conjunction: 0x251c590 spark: 0x136 + 11515531: cap 0: Start a parallel conjunction 0x251c5f0, static_id: 2 + 11515662: cap 0: Create spark for conjunction: 0x251c5f0 spark: 0x137 + 11515846: cap 0: Start a parallel conjunction 0x251c650, static_id: 2 + 11515972: cap 0: Create spark for conjunction: 0x251c650 spark: 0x138 + 11516175: cap 0: Start a parallel conjunction 0x251c6b0, static_id: 2 + 11516296: cap 0: Create spark for conjunction: 0x251c6b0 spark: 0x139 + 11516476: cap 0: Start a parallel conjunction 0x251c710, static_id: 2 + 11516598: cap 0: Create spark for conjunction: 0x251c710 spark: 0x13a + 11516782: cap 0: Start a parallel conjunction 0x251c770, static_id: 2 + 11516908: cap 0: Create spark for conjunction: 0x251c770 spark: 0x13b + 11517093: cap 0: Start a parallel conjunction 0x251c7d0, static_id: 2 + 11517214: cap 0: Create spark for conjunction: 0x251c7d0 spark: 0x13c + 11517394: cap 0: Start a parallel conjunction 0x251c830, static_id: 2 + 11517529: cap 0: Create spark for conjunction: 0x251c830 spark: 0x13d + 11517705: cap 0: Start a parallel conjunction 0x251c890, static_id: 2 + 11517826: cap 0: Create spark for conjunction: 0x251c890 spark: 0x13e + 11518011: cap 0: Start a parallel conjunction 0x251c8f0, static_id: 2 + 11518141: cap 0: Create spark for conjunction: 0x251c8f0 spark: 0x13f + 11518317: cap 0: Start a parallel conjunction 0x251c950, static_id: 2 + 11518443: cap 0: Create spark for conjunction: 0x251c950 spark: 0x140 + 11518627: cap 0: Start a parallel conjunction 0x251c9b0, static_id: 2 + 11518758: cap 0: Create spark for conjunction: 0x251c9b0 spark: 0x141 + 11518942: cap 0: Start a parallel conjunction 0x251ca10, static_id: 2 + 11519068: cap 0: Create spark for conjunction: 0x251ca10 spark: 0x142 + 11519257: cap 0: Start a parallel conjunction 0x251ca70, static_id: 2 + 11519383: cap 0: Create spark for conjunction: 0x251ca70 spark: 0x143 + 11519563: cap 0: Start a parallel conjunction 0x251cad0, static_id: 2 + 11519694: cap 0: Create spark for conjunction: 0x251cad0 spark: 0x144 + 11519878: cap 0: Start a parallel conjunction 0x251cb30, static_id: 2 + 11520009: cap 0: Create spark for conjunction: 0x251cb30 spark: 0x145 + 11520198: cap 0: Start a parallel conjunction 0x251cb90, static_id: 2 + 11520319: cap 0: Create spark for conjunction: 0x251cb90 spark: 0x146 + 11520490: cap 0: Start a parallel conjunction 0x251cbf0, static_id: 2 + 11520621: cap 0: Create spark for conjunction: 0x251cbf0 spark: 0x147 + 11520801: cap 0: Start a parallel conjunction 0x251cc50, static_id: 2 + 11520922: cap 0: Create spark for conjunction: 0x251cc50 spark: 0x148 + 11521111: cap 0: Start a parallel conjunction 0x251ccb0, static_id: 2 + 11521251: cap 0: Create spark for conjunction: 0x251ccb0 spark: 0x149 + 11521422: cap 0: Start a parallel conjunction 0x251cd10, static_id: 2 + 11521548: cap 0: Create spark for conjunction: 0x251cd10 spark: 0x14a + 11521741: cap 0: Start a parallel conjunction 0x251cd70, static_id: 2 + 11521876: cap 0: Create spark for conjunction: 0x251cd70 spark: 0x14b + 11522065: cap 0: Start a parallel conjunction 0x251cdd0, static_id: 2 + 11522187: cap 0: Create spark for conjunction: 0x251cdd0 spark: 0x14c + 11522371: cap 0: Start a parallel conjunction 0x251ce30, static_id: 2 + 11522506: cap 0: Create spark for conjunction: 0x251ce30 spark: 0x14d + 11522686: cap 0: Start a parallel conjunction 0x251ce90, static_id: 2 + 11522808: cap 0: Create spark for conjunction: 0x251ce90 spark: 0x14e + 11522992: cap 0: Start a parallel conjunction 0x251cef0, static_id: 2 + 11523118: cap 0: Create spark for conjunction: 0x251cef0 spark: 0x14f + 11523298: cap 0: Start a parallel conjunction 0x251cf50, static_id: 2 + 11523424: cap 0: Create spark for conjunction: 0x251cf50 spark: 0x150 + 11523609: cap 0: Start a parallel conjunction 0x251cfb0, static_id: 2 + 11523739: cap 0: Create spark for conjunction: 0x251cfb0 spark: 0x151 + 11524059: cap 0: Start a parallel conjunction 0x251d010, static_id: 2 + 11524180: cap 0: Create spark for conjunction: 0x251d010 spark: 0x152 + 11524378: cap 0: Start a parallel conjunction 0x251d070, static_id: 2 + 11524518: cap 0: Create spark for conjunction: 0x251d070 spark: 0x153 + 11524698: cap 0: Start a parallel conjunction 0x251d0d0, static_id: 2 + 11524828: cap 0: Create spark for conjunction: 0x251d0d0 spark: 0x154 + 11525013: cap 0: Start a parallel conjunction 0x251d130, static_id: 2 + 11525134: cap 0: Create spark for conjunction: 0x251d130 spark: 0x155 + 11525319: cap 0: Start a parallel conjunction 0x251d190, static_id: 2 + 11525449: cap 0: Create spark for conjunction: 0x251d190 spark: 0x156 + 11525625: cap 0: Start a parallel conjunction 0x251d1f0, static_id: 2 + 11525760: cap 0: Create spark for conjunction: 0x251d1f0 spark: 0x157 + 11525940: cap 0: Start a parallel conjunction 0x251d250, static_id: 2 + 11526061: cap 0: Create spark for conjunction: 0x251d250 spark: 0x158 + 11526250: cap 0: Start a parallel conjunction 0x251d2b0, static_id: 2 + 11526381: cap 0: Create spark for conjunction: 0x251d2b0 spark: 0x159 + 11526556: cap 0: Start a parallel conjunction 0x251d310, static_id: 2 + 11526678: cap 0: Create spark for conjunction: 0x251d310 spark: 0x15a + 11527038: cap 0: Start a parallel conjunction 0x251d370, static_id: 2 + 11527168: cap 0: Create spark for conjunction: 0x251d370 spark: 0x15b + 11527357: cap 0: Start a parallel conjunction 0x251d3d0, static_id: 2 + 11527479: cap 0: Create spark for conjunction: 0x251d3d0 spark: 0x15c + 11527659: cap 0: Start a parallel conjunction 0x251d430, static_id: 2 + 11527794: cap 0: Create spark for conjunction: 0x251d430 spark: 0x15d + 11527974: cap 0: Start a parallel conjunction 0x251d490, static_id: 2 + 11528095: cap 0: Create spark for conjunction: 0x251d490 spark: 0x15e + 11528293: cap 0: Start a parallel conjunction 0x251d4f0, static_id: 2 + 11528424: cap 0: Create spark for conjunction: 0x251d4f0 spark: 0x15f + 11528608: cap 0: Start a parallel conjunction 0x251d550, static_id: 2 + 11528730: cap 0: Create spark for conjunction: 0x251d550 spark: 0x160 + 11528914: cap 0: Start a parallel conjunction 0x251d5b0, static_id: 2 + 11529049: cap 0: Create spark for conjunction: 0x251d5b0 spark: 0x161 + 11529234: cap 0: Start a parallel conjunction 0x251d610, static_id: 2 + 11529355: cap 0: Create spark for conjunction: 0x251d610 spark: 0x162 + 11529567: cap 0: Start a parallel conjunction 0x251d670, static_id: 2 + 11529693: cap 0: Create spark for conjunction: 0x251d670 spark: 0x163 + 11529877: cap 0: Start a parallel conjunction 0x251d6d0, static_id: 2 + 11530003: cap 0: Create spark for conjunction: 0x251d6d0 spark: 0x164 + 11530197: cap 0: Start a parallel conjunction 0x251d730, static_id: 2 + 11530323: cap 0: Create spark for conjunction: 0x251d730 spark: 0x165 + 11530512: cap 0: Start a parallel conjunction 0x251d790, static_id: 2 + 11530633: cap 0: Create spark for conjunction: 0x251d790 spark: 0x166 + 11530809: cap 0: Start a parallel conjunction 0x251d7f0, static_id: 2 + 11530944: cap 0: Create spark for conjunction: 0x251d7f0 spark: 0x167 + 11531124: cap 0: Start a parallel conjunction 0x251d850, static_id: 2 + 11531245: cap 0: Create spark for conjunction: 0x251d850 spark: 0x168 + 11531430: cap 0: Start a parallel conjunction 0x251d8b0, static_id: 2 + 11531556: cap 0: Create spark for conjunction: 0x251d8b0 spark: 0x169 + 11531731: cap 0: Start a parallel conjunction 0x251d910, static_id: 2 + 11531853: cap 0: Create spark for conjunction: 0x251d910 spark: 0x16a + 11532033: cap 0: Start a parallel conjunction 0x251d970, static_id: 2 + 11532163: cap 0: Create spark for conjunction: 0x251d970 spark: 0x16b + 11532348: cap 0: Start a parallel conjunction 0x251d9d0, static_id: 2 + 11532469: cap 0: Create spark for conjunction: 0x251d9d0 spark: 0x16c + 11532649: cap 0: Start a parallel conjunction 0x251da30, static_id: 2 + 11532784: cap 0: Create spark for conjunction: 0x251da30 spark: 0x16d + 11532969: cap 0: Start a parallel conjunction 0x251da90, static_id: 2 + 11533090: cap 0: Create spark for conjunction: 0x251da90 spark: 0x16e + 11533279: cap 0: Start a parallel conjunction 0x251daf0, static_id: 2 + 11533405: cap 0: Create spark for conjunction: 0x251daf0 spark: 0x16f + 11533590: cap 0: Start a parallel conjunction 0x251db50, static_id: 2 + 11533711: cap 0: Create spark for conjunction: 0x251db50 spark: 0x170 + 11533887: cap 0: Start a parallel conjunction 0x251dbb0, static_id: 2 + 11534017: cap 0: Create spark for conjunction: 0x251dbb0 spark: 0x171 + 11534202: cap 0: Start a parallel conjunction 0x251dc10, static_id: 2 + 11534323: cap 0: Create spark for conjunction: 0x251dc10 spark: 0x172 + 11534656: cap 0: Start a parallel conjunction 0x251dc70, static_id: 2 + 11534787: cap 0: Create spark for conjunction: 0x251dc70 spark: 0x173 + 11534962: cap 0: Start a parallel conjunction 0x251dcd0, static_id: 2 + 11535309: cap 0: Create spark for conjunction: 0x251dcd0 spark: 0x174 + 11535507: cap 0: Start a parallel conjunction 0x251dd30, static_id: 2 + 11535633: cap 0: Create spark for conjunction: 0x251dd30 spark: 0x175 + 11535817: cap 0: Start a parallel conjunction 0x251dd90, static_id: 2 + 11535939: cap 0: Create spark for conjunction: 0x251dd90 spark: 0x176 + 11536114: cap 0: Start a parallel conjunction 0x251ddf0, static_id: 2 + 11536249: cap 0: Create spark for conjunction: 0x251ddf0 spark: 0x177 + 11536443: cap 0: Start a parallel conjunction 0x251de50, static_id: 2 + 11536569: cap 0: Create spark for conjunction: 0x251de50 spark: 0x178 + 11536771: cap 0: Start a parallel conjunction 0x251deb0, static_id: 2 + 11536902: cap 0: Create spark for conjunction: 0x251deb0 spark: 0x179 + 11537091: cap 0: Start a parallel conjunction 0x251df10, static_id: 2 + 11537212: cap 0: Create spark for conjunction: 0x251df10 spark: 0x17a + 11537397: cap 0: Start a parallel conjunction 0x251df70, static_id: 2 + 11537523: cap 0: Create spark for conjunction: 0x251df70 spark: 0x17b + 11537820: cap 0: Start a parallel conjunction 0x251dfd0, static_id: 2 + 11537941: cap 0: Create spark for conjunction: 0x251dfd0 spark: 0x17c + 11538261: cap 0: Start a parallel conjunction 0x251e030, static_id: 2 + 11538396: cap 0: Create spark for conjunction: 0x251e030 spark: 0x17d + 11538576: cap 0: Start a parallel conjunction 0x251e090, static_id: 2 + 11538697: cap 0: Create spark for conjunction: 0x251e090 spark: 0x17e + 11538882: cap 0: Start a parallel conjunction 0x251e0f0, static_id: 2 + 11539012: cap 0: Create spark for conjunction: 0x251e0f0 spark: 0x17f + 11539188: cap 0: Start a parallel conjunction 0x251e150, static_id: 2 + 11539314: cap 0: Create spark for conjunction: 0x251e150 spark: 0x180 + 11539507: cap 0: Start a parallel conjunction 0x251e1b0, static_id: 2 + 11539638: cap 0: Create spark for conjunction: 0x251e1b0 spark: 0x181 + 11539822: cap 0: Start a parallel conjunction 0x251e210, static_id: 2 + 11539944: cap 0: Create spark for conjunction: 0x251e210 spark: 0x182 + 11540137: cap 0: Start a parallel conjunction 0x251e270, static_id: 2 + 11540272: cap 0: Create spark for conjunction: 0x251e270 spark: 0x183 + 11540448: cap 0: Start a parallel conjunction 0x251e2d0, static_id: 2 + 11540614: cap 0: Create spark for conjunction: 0x251e2d0 spark: 0x184 + 11540803: cap 0: Start a parallel conjunction 0x251e330, static_id: 2 + 11540929: cap 0: Create spark for conjunction: 0x251e330 spark: 0x185 + 11541118: cap 0: Start a parallel conjunction 0x251e390, static_id: 2 + 11541240: cap 0: Create spark for conjunction: 0x251e390 spark: 0x186 + 11541577: cap 0: Start a parallel conjunction 0x251e3f0, static_id: 2 + 11541712: cap 0: Create spark for conjunction: 0x251e3f0 spark: 0x187 + 11541897: cap 0: Start a parallel conjunction 0x251e450, static_id: 2 + 11542059: cap 0: Create spark for conjunction: 0x251e450 spark: 0x188 + 11542261: cap 0: Start a parallel conjunction 0x251e4b0, static_id: 2 + 11542383: cap 0: Create spark for conjunction: 0x251e4b0 spark: 0x189 + 11542558: cap 0: Start a parallel conjunction 0x251e510, static_id: 2 + 11542680: cap 0: Create spark for conjunction: 0x251e510 spark: 0x18a + 11542864: cap 0: Start a parallel conjunction 0x251e570, static_id: 2 + 11542990: cap 0: Create spark for conjunction: 0x251e570 spark: 0x18b + 11543175: cap 0: Start a parallel conjunction 0x251e5d0, static_id: 2 + 11543296: cap 0: Create spark for conjunction: 0x251e5d0 spark: 0x18c + 11543476: cap 0: Start a parallel conjunction 0x251e630, static_id: 2 + 11543620: cap 0: Create spark for conjunction: 0x251e630 spark: 0x18d + 11543800: cap 0: Start a parallel conjunction 0x251e690, static_id: 2 + 11543922: cap 0: Create spark for conjunction: 0x251e690 spark: 0x18e + 11544111: cap 0: Start a parallel conjunction 0x251e6f0, static_id: 2 + 11544241: cap 0: Create spark for conjunction: 0x251e6f0 spark: 0x18f + 11544417: cap 0: Start a parallel conjunction 0x251e750, static_id: 2 + 11544547: cap 0: Create spark for conjunction: 0x251e750 spark: 0x190 + 11544732: cap 0: Start a parallel conjunction 0x251e7b0, static_id: 2 + 11544858: cap 0: Create spark for conjunction: 0x251e7b0 spark: 0x191 + 11545042: cap 0: Start a parallel conjunction 0x251e810, static_id: 2 + 11545164: cap 0: Create spark for conjunction: 0x251e810 spark: 0x192 + 11545353: cap 0: Start a parallel conjunction 0x251e870, static_id: 2 + 11545479: cap 0: Create spark for conjunction: 0x251e870 spark: 0x193 + 11545659: cap 0: Start a parallel conjunction 0x251e8d0, static_id: 2 + 11545785: cap 0: Create spark for conjunction: 0x251e8d0 spark: 0x194 + 11545974: cap 0: Start a parallel conjunction 0x251e930, static_id: 2 + 11546100: cap 0: Create spark for conjunction: 0x251e930 spark: 0x195 + 11546293: cap 0: Start a parallel conjunction 0x251e990, static_id: 2 + 11546415: cap 0: Create spark for conjunction: 0x251e990 spark: 0x196 + 11546590: cap 0: Start a parallel conjunction 0x251e9f0, static_id: 2 + 11546725: cap 0: Create spark for conjunction: 0x251e9f0 spark: 0x197 + 11546910: cap 0: Start a parallel conjunction 0x251ea50, static_id: 2 + 11547036: cap 0: Create spark for conjunction: 0x251ea50 spark: 0x198 + 11547243: cap 0: Start a parallel conjunction 0x251eab0, static_id: 2 + 11547378: cap 0: Create spark for conjunction: 0x251eab0 spark: 0x199 + 11547562: cap 0: Start a parallel conjunction 0x251eb10, static_id: 2 + 11547684: cap 0: Create spark for conjunction: 0x251eb10 spark: 0x19a + 11547868: cap 0: Start a parallel conjunction 0x251eb70, static_id: 2 + 11547990: cap 0: Create spark for conjunction: 0x251eb70 spark: 0x19b + 11548174: cap 0: Start a parallel conjunction 0x251ebd0, static_id: 2 + 11548296: cap 0: Create spark for conjunction: 0x251ebd0 spark: 0x19c + 11548476: cap 0: Start a parallel conjunction 0x251ec30, static_id: 2 + 11548602: cap 0: Create spark for conjunction: 0x251ec30 spark: 0x19d + 11548782: cap 0: Start a parallel conjunction 0x251ec90, static_id: 2 + 11548903: cap 0: Create spark for conjunction: 0x251ec90 spark: 0x19e + 11549092: cap 0: Start a parallel conjunction 0x251ecf0, static_id: 2 + 11549223: cap 0: Create spark for conjunction: 0x251ecf0 spark: 0x19f + 11549403: cap 0: Start a parallel conjunction 0x251ed50, static_id: 2 + 11549524: cap 0: Create spark for conjunction: 0x251ed50 spark: 0x1a0 + 11549709: cap 0: Start a parallel conjunction 0x251edb0, static_id: 2 + 11549839: cap 0: Create spark for conjunction: 0x251edb0 spark: 0x1a1 + 11550019: cap 0: Start a parallel conjunction 0x251ee10, static_id: 2 + 11550141: cap 0: Create spark for conjunction: 0x251ee10 spark: 0x1a2 + 11550330: cap 0: Start a parallel conjunction 0x251ee70, static_id: 2 + 11550465: cap 0: Create spark for conjunction: 0x251ee70 spark: 0x1a3 + 11550658: cap 0: Start a parallel conjunction 0x251eed0, static_id: 2 + 11550784: cap 0: Create spark for conjunction: 0x251eed0 spark: 0x1a4 + 11550982: cap 0: Start a parallel conjunction 0x251ef30, static_id: 2 + 11551108: cap 0: Create spark for conjunction: 0x251ef30 spark: 0x1a5 + 11551293: cap 0: Start a parallel conjunction 0x251ef90, static_id: 2 + 11551419: cap 0: Create spark for conjunction: 0x251ef90 spark: 0x1a6 + 11551752: cap 0: Start a parallel conjunction 0x251eff0, static_id: 2 + 11551887: cap 0: Create spark for conjunction: 0x251eff0 spark: 0x1a7 + 11552076: cap 0: Start a parallel conjunction 0x251f050, static_id: 2 + 11552197: cap 0: Create spark for conjunction: 0x251f050 spark: 0x1a8 + 11552386: cap 0: Start a parallel conjunction 0x251f0b0, static_id: 2 + 11552517: cap 0: Create spark for conjunction: 0x251f0b0 spark: 0x1a9 + 11552755: cap 0: Start a parallel conjunction 0x251f110, static_id: 2 + 11552886: cap 0: Create spark for conjunction: 0x251f110 spark: 0x1aa + 11553066: cap 0: Start a parallel conjunction 0x251f170, static_id: 2 + 11553196: cap 0: Create spark for conjunction: 0x251f170 spark: 0x1ab + 11553390: cap 0: Start a parallel conjunction 0x251f1d0, static_id: 2 + 11553511: cap 0: Create spark for conjunction: 0x251f1d0 spark: 0x1ac + 11553696: cap 0: Start a parallel conjunction 0x251f230, static_id: 2 + 11553835: cap 0: Create spark for conjunction: 0x251f230 spark: 0x1ad + 11554015: cap 0: Start a parallel conjunction 0x251f290, static_id: 2 + 11554146: cap 0: Create spark for conjunction: 0x251f290 spark: 0x1ae + 11554330: cap 0: Start a parallel conjunction 0x251f2f0, static_id: 2 + 11554465: cap 0: Create spark for conjunction: 0x251f2f0 spark: 0x1af + 11554645: cap 0: Start a parallel conjunction 0x251f350, static_id: 2 + 11554767: cap 0: Create spark for conjunction: 0x251f350 spark: 0x1b0 + 11554956: cap 0: Start a parallel conjunction 0x251f3b0, static_id: 2 + 11555082: cap 0: Create spark for conjunction: 0x251f3b0 spark: 0x1b1 + 11555262: cap 0: Start a parallel conjunction 0x251f410, static_id: 2 + 11555383: cap 0: Create spark for conjunction: 0x251f410 spark: 0x1b2 + 11555662: cap 0: Start a parallel conjunction 0x251f470, static_id: 2 + 11555788: cap 0: Create spark for conjunction: 0x251f470 spark: 0x1b3 + 11555964: cap 0: Start a parallel conjunction 0x251f4d0, static_id: 2 + 11556090: cap 0: Create spark for conjunction: 0x251f4d0 spark: 0x1b4 + 11556270: cap 0: Start a parallel conjunction 0x251f530, static_id: 2 + 11556391: cap 0: Create spark for conjunction: 0x251f530 spark: 0x1b5 + 11556576: cap 0: Start a parallel conjunction 0x251f590, static_id: 2 + 11556697: cap 0: Create spark for conjunction: 0x251f590 spark: 0x1b6 + 11556877: cap 0: Start a parallel conjunction 0x251f5f0, static_id: 2 + 11557008: cap 0: Create spark for conjunction: 0x251f5f0 spark: 0x1b7 + 11557188: cap 0: Start a parallel conjunction 0x251f650, static_id: 2 + 11557309: cap 0: Create spark for conjunction: 0x251f650 spark: 0x1b8 + 11557503: cap 0: Start a parallel conjunction 0x251f6b0, static_id: 2 + 11557638: cap 0: Create spark for conjunction: 0x251f6b0 spark: 0x1b9 + 11557818: cap 0: Start a parallel conjunction 0x251f710, static_id: 2 + 11557944: cap 0: Create spark for conjunction: 0x251f710 spark: 0x1ba + 11558137: cap 0: Start a parallel conjunction 0x251f770, static_id: 2 + 11558268: cap 0: Create spark for conjunction: 0x251f770 spark: 0x1bb + 11558452: cap 0: Start a parallel conjunction 0x251f7d0, static_id: 2 + 11558578: cap 0: Create spark for conjunction: 0x251f7d0 spark: 0x1bc + 11558754: cap 0: Start a parallel conjunction 0x251f830, static_id: 2 + 11558893: cap 0: Create spark for conjunction: 0x251f830 spark: 0x1bd + 11559069: cap 0: Start a parallel conjunction 0x251f890, static_id: 2 + 11559190: cap 0: Create spark for conjunction: 0x251f890 spark: 0x1be + 11559375: cap 0: Start a parallel conjunction 0x251f8f0, static_id: 2 + 11559505: cap 0: Create spark for conjunction: 0x251f8f0 spark: 0x1bf + 11559681: cap 0: Start a parallel conjunction 0x251f950, static_id: 2 + 11559802: cap 0: Create spark for conjunction: 0x251f950 spark: 0x1c0 + 11559982: cap 0: Start a parallel conjunction 0x251f9b0, static_id: 2 + 11560099: cap 0: Create spark for conjunction: 0x251f9b0 spark: 0x1c1 + 11560279: cap 0: Start a parallel conjunction 0x251fa10, static_id: 2 + 11560396: cap 0: Create spark for conjunction: 0x251fa10 spark: 0x1c2 + 11560581: cap 0: Start a parallel conjunction 0x251fa70, static_id: 2 + 11560711: cap 0: Create spark for conjunction: 0x251fa70 spark: 0x1c3 + 11560896: cap 0: Start a parallel conjunction 0x251fad0, static_id: 2 + 11561026: cap 0: Create spark for conjunction: 0x251fad0 spark: 0x1c4 + 11561215: cap 0: Start a parallel conjunction 0x251fb30, static_id: 2 + 11561350: cap 0: Create spark for conjunction: 0x251fb30 spark: 0x1c5 + 11561539: cap 0: Start a parallel conjunction 0x251fb90, static_id: 2 + 11561665: cap 0: Create spark for conjunction: 0x251fb90 spark: 0x1c6 + 11561836: cap 0: Start a parallel conjunction 0x251fbf0, static_id: 2 + 11561971: cap 0: Create spark for conjunction: 0x251fbf0 spark: 0x1c7 + 11562151: cap 0: Start a parallel conjunction 0x251fc50, static_id: 2 + 11562277: cap 0: Create spark for conjunction: 0x251fc50 spark: 0x1c8 + 11562466: cap 0: Start a parallel conjunction 0x251fcb0, static_id: 2 + 11562606: cap 0: Create spark for conjunction: 0x251fcb0 spark: 0x1c9 + 11562781: cap 0: Start a parallel conjunction 0x251fd10, static_id: 2 + 11562907: cap 0: Create spark for conjunction: 0x251fd10 spark: 0x1ca + 11563087: cap 0: Start a parallel conjunction 0x251fd70, static_id: 2 + 11563209: cap 0: Create spark for conjunction: 0x251fd70 spark: 0x1cb + 11563402: cap 0: Start a parallel conjunction 0x251fdd0, static_id: 2 + 11563524: cap 0: Create spark for conjunction: 0x251fdd0 spark: 0x1cc + 11563713: cap 0: Start a parallel conjunction 0x251fe30, static_id: 2 + 11563848: cap 0: Create spark for conjunction: 0x251fe30 spark: 0x1cd + 11564032: cap 0: Start a parallel conjunction 0x251fe90, static_id: 2 + 11564154: cap 0: Create spark for conjunction: 0x251fe90 spark: 0x1ce + 11564338: cap 0: Start a parallel conjunction 0x251fef0, static_id: 2 + 11564469: cap 0: Create spark for conjunction: 0x251fef0 spark: 0x1cf + 11564640: cap 0: Start a parallel conjunction 0x251ff50, static_id: 2 + 11564874: cap 0: Create spark for conjunction: 0x251ff50 spark: 0x1d0 + 11565175: cap 0: Start a parallel conjunction 0x251ffb0, static_id: 2 + 11565301: cap 0: Create spark for conjunction: 0x251ffb0 spark: 0x1d1 + 11565711: cap 0: Start a parallel conjunction 0x2520010, static_id: 2 + 11565832: cap 0: Create spark for conjunction: 0x2520010 spark: 0x1d2 + 11566026: cap 0: Start a parallel conjunction 0x2520070, static_id: 2 + 11566152: cap 0: Create spark for conjunction: 0x2520070 spark: 0x1d3 + 11566327: cap 0: Start a parallel conjunction 0x25200d0, static_id: 2 + 11566453: cap 0: Create spark for conjunction: 0x25200d0 spark: 0x1d4 + 11566638: cap 0: Start a parallel conjunction 0x2520130, static_id: 2 + 11566768: cap 0: Create spark for conjunction: 0x2520130 spark: 0x1d5 + 11566966: cap 0: Start a parallel conjunction 0x2520190, static_id: 2 + 11567088: cap 0: Create spark for conjunction: 0x2520190 spark: 0x1d6 + 11567461: cap 0: Start a parallel conjunction 0x25201f0, static_id: 2 + 11567596: cap 0: Create spark for conjunction: 0x25201f0 spark: 0x1d7 + 11567781: cap 0: Start a parallel conjunction 0x2520250, static_id: 2 + 11567907: cap 0: Create spark for conjunction: 0x2520250 spark: 0x1d8 + 11568105: cap 0: Start a parallel conjunction 0x25202b0, static_id: 2 + 11568226: cap 0: Create spark for conjunction: 0x25202b0 spark: 0x1d9 + 11568397: cap 0: Start a parallel conjunction 0x2520310, static_id: 2 + 11568523: cap 0: Create spark for conjunction: 0x2520310 spark: 0x1da + 11568708: cap 0: Start a parallel conjunction 0x2520370, static_id: 2 + 11568834: cap 0: Create spark for conjunction: 0x2520370 spark: 0x1db + 11569018: cap 0: Start a parallel conjunction 0x25203d0, static_id: 2 + 11569140: cap 0: Create spark for conjunction: 0x25203d0 spark: 0x1dc + 11569320: cap 0: Start a parallel conjunction 0x2520430, static_id: 2 + 11569455: cap 0: Create spark for conjunction: 0x2520430 spark: 0x1dd + 11569630: cap 0: Start a parallel conjunction 0x2520490, static_id: 2 + 11569752: cap 0: Create spark for conjunction: 0x2520490 spark: 0x1de + 11569936: cap 0: Start a parallel conjunction 0x25204f0, static_id: 2 + 11570067: cap 0: Create spark for conjunction: 0x25204f0 spark: 0x1df + 11570242: cap 0: Start a parallel conjunction 0x2520550, static_id: 2 + 11570364: cap 0: Create spark for conjunction: 0x2520550 spark: 0x1e0 + 11570544: cap 0: Start a parallel conjunction 0x25205b0, static_id: 2 + 11570670: cap 0: Create spark for conjunction: 0x25205b0 spark: 0x1e1 + 11570850: cap 0: Start a parallel conjunction 0x2520610, static_id: 2 + 11570971: cap 0: Create spark for conjunction: 0x2520610 spark: 0x1e2 + 11571160: cap 0: Start a parallel conjunction 0x2520670, static_id: 2 + 11571295: cap 0: Create spark for conjunction: 0x2520670 spark: 0x1e3 + 11571466: cap 0: Start a parallel conjunction 0x25206d0, static_id: 2 + 11571601: cap 0: Create spark for conjunction: 0x25206d0 spark: 0x1e4 + 11571795: cap 0: Start a parallel conjunction 0x2520730, static_id: 2 + 11571921: cap 0: Create spark for conjunction: 0x2520730 spark: 0x1e5 + 11572114: cap 0: Start a parallel conjunction 0x2520790, static_id: 2 + 11572240: cap 0: Create spark for conjunction: 0x2520790 spark: 0x1e6 + 11572416: cap 0: Start a parallel conjunction 0x25207f0, static_id: 2 + 11572546: cap 0: Create spark for conjunction: 0x25207f0 spark: 0x1e7 + 11572735: cap 0: Start a parallel conjunction 0x2520850, static_id: 2 + 11572861: cap 0: Create spark for conjunction: 0x2520850 spark: 0x1e8 + 11573055: cap 0: Start a parallel conjunction 0x25208b0, static_id: 2 + 11573190: cap 0: Create spark for conjunction: 0x25208b0 spark: 0x1e9 + 11573365: cap 0: Start a parallel conjunction 0x2520910, static_id: 2 + 11573487: cap 0: Create spark for conjunction: 0x2520910 spark: 0x1ea + 11573676: cap 0: Start a parallel conjunction 0x2520970, static_id: 2 + 11573802: cap 0: Create spark for conjunction: 0x2520970 spark: 0x1eb + 11573986: cap 0: Start a parallel conjunction 0x25209d0, static_id: 2 + 11574112: cap 0: Create spark for conjunction: 0x25209d0 spark: 0x1ec + 11574288: cap 0: Start a parallel conjunction 0x2520a30, static_id: 2 + 11574427: cap 0: Create spark for conjunction: 0x2520a30 spark: 0x1ed + 11574603: cap 0: Start a parallel conjunction 0x2520a90, static_id: 2 + 11574724: cap 0: Create spark for conjunction: 0x2520a90 spark: 0x1ee + 11574909: cap 0: Start a parallel conjunction 0x2520af0, static_id: 2 + 11575039: cap 0: Create spark for conjunction: 0x2520af0 spark: 0x1ef + 11575219: cap 0: Start a parallel conjunction 0x2520b50, static_id: 2 + 11575341: cap 0: Create spark for conjunction: 0x2520b50 spark: 0x1f0 + 11575521: cap 0: Start a parallel conjunction 0x2520bb0, static_id: 2 + 11575647: cap 0: Create spark for conjunction: 0x2520bb0 spark: 0x1f1 + 11575827: cap 0: Start a parallel conjunction 0x2520c10, static_id: 2 + 11575948: cap 0: Create spark for conjunction: 0x2520c10 spark: 0x1f2 + 11576137: cap 0: Start a parallel conjunction 0x2520c70, static_id: 2 + 11576277: cap 0: Create spark for conjunction: 0x2520c70 spark: 0x1f3 + 11576452: cap 0: Start a parallel conjunction 0x2520cd0, static_id: 2 + 11576578: cap 0: Create spark for conjunction: 0x2520cd0 spark: 0x1f4 + 11576772: cap 0: Start a parallel conjunction 0x2520d30, static_id: 2 + 11576898: cap 0: Create spark for conjunction: 0x2520d30 spark: 0x1f5 + 11577087: cap 0: Start a parallel conjunction 0x2520d90, static_id: 2 + 11577208: cap 0: Create spark for conjunction: 0x2520d90 spark: 0x1f6 + 11577393: cap 0: Start a parallel conjunction 0x2520df0, static_id: 2 + 11577523: cap 0: Create spark for conjunction: 0x2520df0 spark: 0x1f7 + 11577712: cap 0: Start a parallel conjunction 0x2520e50, static_id: 2 + 11577834: cap 0: Create spark for conjunction: 0x2520e50 spark: 0x1f8 + 11578032: cap 0: Start a parallel conjunction 0x2520eb0, static_id: 2 + 11578153: cap 0: Create spark for conjunction: 0x2520eb0 spark: 0x1f9 + 11578324: cap 0: Start a parallel conjunction 0x2520f10, static_id: 2 + 11578450: cap 0: Create spark for conjunction: 0x2520f10 spark: 0x1fa + 11578635: cap 0: Start a parallel conjunction 0x2520f70, static_id: 2 + 11578765: cap 0: Create spark for conjunction: 0x2520f70 spark: 0x1fb + 11579089: cap 0: Start a parallel conjunction 0x2520fd0, static_id: 2 + 11579211: cap 0: Create spark for conjunction: 0x2520fd0 spark: 0x1fc + 11579530: cap 0: Start a parallel conjunction 0x2521030, static_id: 2 + 11579670: cap 0: Create spark for conjunction: 0x2521030 spark: 0x1fd + 11579850: cap 0: Start a parallel conjunction 0x2521090, static_id: 2 + 11579971: cap 0: Create spark for conjunction: 0x2521090 spark: 0x1fe + 11580160: cap 0: Start a parallel conjunction 0x25210f0, static_id: 2 + 11580291: cap 0: Create spark for conjunction: 0x25210f0 spark: 0x1ff + 11580466: cap 0: Start a parallel conjunction 0x2521150, static_id: 2 + 11580588: cap 0: Create spark for conjunction: 0x2521150 spark: 0x200 + 11580772: cap 0: Start a parallel conjunction 0x25211b0, static_id: 2 + 11625201: cap 1: Trying to steal a spark + 11626915: cap 1: stealing a spark from cap 0 + 11631217: cap 0: Create spark for conjunction: 0x25211b0 spark: 0x201 + 11631456: cap 0: Start a parallel conjunction 0x2521210, static_id: 2 + 11631586: cap 0: Create spark for conjunction: 0x2521210 spark: 0x202 + 11631789: cap 0: Start a parallel conjunction 0x2521270, static_id: 2 + 11631924: cap 0: Create spark for conjunction: 0x2521270 spark: 0x203 + 11632104: cap 0: Start a parallel conjunction 0x25212d0, static_id: 2 + 11632243: cap 0: Create spark for conjunction: 0x25212d0 spark: 0x204 + 11632437: cap 0: Start a parallel conjunction 0x2521330, static_id: 2 + 11632567: cap 0: Create spark for conjunction: 0x2521330 spark: 0x205 + 11632756: cap 0: Start a parallel conjunction 0x2521390, static_id: 2 + 11632882: cap 0: Create spark for conjunction: 0x2521390 spark: 0x206 + 11633062: cap 0: Start a parallel conjunction 0x25213f0, static_id: 2 + 11633206: cap 0: Create spark for conjunction: 0x25213f0 spark: 0x207 + 11633395: cap 0: Start a parallel conjunction 0x2521450, static_id: 2 + 11633526: cap 0: Create spark for conjunction: 0x2521450 spark: 0x208 + 11633737: cap 0: Start a parallel conjunction 0x25214b0, static_id: 2 + 11633872: cap 0: Create spark for conjunction: 0x25214b0 spark: 0x209 + 11634057: cap 0: Start a parallel conjunction 0x2521510, static_id: 2 + 11634183: cap 0: Create spark for conjunction: 0x2521510 spark: 0x20a + 11634381: cap 0: Start a parallel conjunction 0x2521570, static_id: 2 + 11634511: cap 0: Create spark for conjunction: 0x2521570 spark: 0x20b + 11634705: cap 0: Start a parallel conjunction 0x25215d0, static_id: 2 + 11634831: cap 0: Create spark for conjunction: 0x25215d0 spark: 0x20c + 11635015: cap 0: Start a parallel conjunction 0x2521630, static_id: 2 + 11635159: cap 0: Create spark for conjunction: 0x2521630 spark: 0x20d + 11635344: cap 0: Start a parallel conjunction 0x2521690, static_id: 2 + 11635465: cap 0: Create spark for conjunction: 0x2521690 spark: 0x20e + 11635659: cap 0: Start a parallel conjunction 0x25216f0, static_id: 2 + 11635789: cap 0: Create spark for conjunction: 0x25216f0 spark: 0x20f + 11636037: cap 0: Start a parallel conjunction 0x2521750, static_id: 2 + 11636158: cap 0: Create spark for conjunction: 0x2521750 spark: 0x210 + 11636343: cap 0: Start a parallel conjunction 0x25217b0, static_id: 2 + 11636473: cap 0: Create spark for conjunction: 0x25217b0 spark: 0x211 + 11636649: cap 0: Start a parallel conjunction 0x2521810, static_id: 2 + 11636770: cap 0: Create spark for conjunction: 0x2521810 spark: 0x212 + 11636964: cap 0: Start a parallel conjunction 0x2521870, static_id: 2 + 11637099: cap 0: Create spark for conjunction: 0x2521870 spark: 0x213 + 11637283: cap 0: Start a parallel conjunction 0x25218d0, static_id: 2 + 11637409: cap 0: Create spark for conjunction: 0x25218d0 spark: 0x214 + 11637589: cap 0: Start a parallel conjunction 0x2521930, static_id: 2 + 11637729: cap 0: Create spark for conjunction: 0x2521930 spark: 0x215 + 11637931: cap 0: Start a parallel conjunction 0x2521990, static_id: 2 + 11638062: cap 0: Create spark for conjunction: 0x2521990 spark: 0x216 + 11638246: cap 0: Start a parallel conjunction 0x25219f0, static_id: 2 + 11638377: cap 0: Create spark for conjunction: 0x25219f0 spark: 0x217 + 11638845: cap 0: Start a parallel conjunction 0x2521a50, static_id: 2 + 11638971: cap 0: Create spark for conjunction: 0x2521a50 spark: 0x218 + 11639173: cap 0: Start a parallel conjunction 0x2521ab0, static_id: 2 + 11639304: cap 0: Create spark for conjunction: 0x2521ab0 spark: 0x219 + 11639488: cap 0: Start a parallel conjunction 0x2521b10, static_id: 2 + 11639614: cap 0: Create spark for conjunction: 0x2521b10 spark: 0x21a + 11639799: cap 0: Start a parallel conjunction 0x2521b70, static_id: 2 + 11639929: cap 0: Create spark for conjunction: 0x2521b70 spark: 0x21b + 11640118: cap 0: Start a parallel conjunction 0x2521bd0, static_id: 2 + 11640249: cap 0: Create spark for conjunction: 0x2521bd0 spark: 0x21c + 11640438: cap 0: Start a parallel conjunction 0x2521c30, static_id: 2 + 11640573: cap 0: Create spark for conjunction: 0x2521c30 spark: 0x21d + 11640753: cap 0: Start a parallel conjunction 0x2521c90, static_id: 2 + 11640874: cap 0: Create spark for conjunction: 0x2521c90 spark: 0x21e + 11641063: cap 0: Start a parallel conjunction 0x2521cf0, static_id: 2 + 11641194: cap 0: Create spark for conjunction: 0x2521cf0 spark: 0x21f + 11641374: cap 0: Start a parallel conjunction 0x2521d50, static_id: 2 + 11641495: cap 0: Create spark for conjunction: 0x2521d50 spark: 0x220 + 11641675: cap 0: Start a parallel conjunction 0x2521db0, static_id: 2 + 11641810: cap 0: Create spark for conjunction: 0x2521db0 spark: 0x221 + 11641990: cap 0: Start a parallel conjunction 0x2521e10, static_id: 2 + 11642121: cap 0: Create spark for conjunction: 0x2521e10 spark: 0x222 + 11642305: cap 0: Start a parallel conjunction 0x2521e70, static_id: 2 + 11642436: cap 0: Create spark for conjunction: 0x2521e70 spark: 0x223 + 11642616: cap 0: Start a parallel conjunction 0x2521ed0, static_id: 2 + 11642742: cap 0: Create spark for conjunction: 0x2521ed0 spark: 0x224 + 11642926: cap 0: Start a parallel conjunction 0x2521f30, static_id: 2 + 11643057: cap 0: Create spark for conjunction: 0x2521f30 spark: 0x225 + 11643241: cap 0: Start a parallel conjunction 0x2521f90, static_id: 2 + 11643367: cap 0: Create spark for conjunction: 0x2521f90 spark: 0x226 + 11643691: cap 0: Start a parallel conjunction 0x2521ff0, static_id: 2 + 11643826: cap 0: Create spark for conjunction: 0x2521ff0 spark: 0x227 + 11644011: cap 0: Start a parallel conjunction 0x2522050, static_id: 2 + 11644137: cap 0: Create spark for conjunction: 0x2522050 spark: 0x228 + 11644335: cap 0: Start a parallel conjunction 0x25220b0, static_id: 2 + 11644461: cap 0: Create spark for conjunction: 0x25220b0 spark: 0x229 + 11644645: cap 0: Start a parallel conjunction 0x2522110, static_id: 2 + 11644771: cap 0: Create spark for conjunction: 0x2522110 spark: 0x22a + 11644960: cap 0: Start a parallel conjunction 0x2522170, static_id: 2 + 11645100: cap 0: Create spark for conjunction: 0x2522170 spark: 0x22b + 11645293: cap 0: Start a parallel conjunction 0x25221d0, static_id: 2 + 11645419: cap 0: Create spark for conjunction: 0x25221d0 spark: 0x22c + 11645599: cap 0: Start a parallel conjunction 0x2522230, static_id: 2 + 11646090: cap 0: Create spark for conjunction: 0x2522230 spark: 0x22d + 11646274: cap 0: Start a parallel conjunction 0x2522290, static_id: 2 + 11646391: cap 0: Create spark for conjunction: 0x2522290 spark: 0x22e + 11646841: cap 0: Start a parallel conjunction 0x25222f0, static_id: 2 + 11646972: cap 0: Create spark for conjunction: 0x25222f0 spark: 0x22f + 11647147: cap 0: Start a parallel conjunction 0x2522350, static_id: 2 + 11647269: cap 0: Create spark for conjunction: 0x2522350 spark: 0x230 + 11647453: cap 0: Start a parallel conjunction 0x25223b0, static_id: 2 + 11647579: cap 0: Create spark for conjunction: 0x25223b0 spark: 0x231 + 11647759: cap 0: Start a parallel conjunction 0x2522410, static_id: 2 + 11647881: cap 0: Create spark for conjunction: 0x2522410 spark: 0x232 + 11648070: cap 0: Start a parallel conjunction 0x2522470, static_id: 2 + 11648196: cap 0: Create spark for conjunction: 0x2522470 spark: 0x233 + 11648380: cap 0: Start a parallel conjunction 0x25224d0, static_id: 2 + 11648506: cap 0: Create spark for conjunction: 0x25224d0 spark: 0x234 + 11648691: cap 0: Start a parallel conjunction 0x2522530, static_id: 2 + 11648826: cap 0: Create spark for conjunction: 0x2522530 spark: 0x235 + 11649024: cap 0: Start a parallel conjunction 0x2522590, static_id: 2 + 11649150: cap 0: Create spark for conjunction: 0x2522590 spark: 0x236 + 11649339: cap 0: Start a parallel conjunction 0x25225f0, static_id: 2 + 11649483: cap 0: Create spark for conjunction: 0x25225f0 spark: 0x237 + 11649672: cap 0: Start a parallel conjunction 0x2522650, static_id: 2 + 11649793: cap 0: Create spark for conjunction: 0x2522650 spark: 0x238 + 11649991: cap 0: Start a parallel conjunction 0x25226b0, static_id: 2 + 11650117: cap 0: Create spark for conjunction: 0x25226b0 spark: 0x239 + 11650302: cap 0: Start a parallel conjunction 0x2522710, static_id: 2 + 11650428: cap 0: Create spark for conjunction: 0x2522710 spark: 0x23a + 11650612: cap 0: Start a parallel conjunction 0x2522770, static_id: 2 + 11650738: cap 0: Create spark for conjunction: 0x2522770 spark: 0x23b + 11650936: cap 0: Start a parallel conjunction 0x25227d0, static_id: 2 + 11651058: cap 0: Create spark for conjunction: 0x25227d0 spark: 0x23c + 11651247: cap 0: Start a parallel conjunction 0x2522830, static_id: 2 + 11651386: cap 0: Create spark for conjunction: 0x2522830 spark: 0x23d + 11651562: cap 0: Start a parallel conjunction 0x2522890, static_id: 2 + 11651688: cap 0: Create spark for conjunction: 0x2522890 spark: 0x23e + 11651877: cap 0: Start a parallel conjunction 0x25228f0, static_id: 2 + 11652007: cap 0: Create spark for conjunction: 0x25228f0 spark: 0x23f + 11652183: cap 0: Start a parallel conjunction 0x2522950, static_id: 2 + 11652304: cap 0: Create spark for conjunction: 0x2522950 spark: 0x240 + 11652660: cap 0: Start a parallel conjunction 0x25229b0, static_id: 2 + 11652786: cap 0: Create spark for conjunction: 0x25229b0 spark: 0x241 + 11652966: cap 0: Start a parallel conjunction 0x2522a10, static_id: 2 + 11653087: cap 0: Create spark for conjunction: 0x2522a10 spark: 0x242 + 11653276: cap 0: Start a parallel conjunction 0x2522a70, static_id: 2 + 11653402: cap 0: Create spark for conjunction: 0x2522a70 spark: 0x243 + 11653587: cap 0: Start a parallel conjunction 0x2522ad0, static_id: 2 + 11653713: cap 0: Create spark for conjunction: 0x2522ad0 spark: 0x244 + 11653897: cap 0: Start a parallel conjunction 0x2522b30, static_id: 2 + 11654028: cap 0: Create spark for conjunction: 0x2522b30 spark: 0x245 + 11654221: cap 0: Start a parallel conjunction 0x2522b90, static_id: 2 + 11654347: cap 0: Create spark for conjunction: 0x2522b90 spark: 0x246 + 11654532: cap 0: Start a parallel conjunction 0x2522bf0, static_id: 2 + 11654676: cap 0: Create spark for conjunction: 0x2522bf0 spark: 0x247 + 11654865: cap 0: Start a parallel conjunction 0x2522c50, static_id: 2 + 11654986: cap 0: Create spark for conjunction: 0x2522c50 spark: 0x248 + 11655189: cap 0: Start a parallel conjunction 0x2522cb0, static_id: 2 + 11655328: cap 0: Create spark for conjunction: 0x2522cb0 spark: 0x249 + 11655504: cap 0: Start a parallel conjunction 0x2522d10, static_id: 2 + 11655630: cap 0: Create spark for conjunction: 0x2522d10 spark: 0x24a + 11655828: cap 0: Start a parallel conjunction 0x2522d70, static_id: 2 + 11655958: cap 0: Create spark for conjunction: 0x2522d70 spark: 0x24b + 11656152: cap 0: Start a parallel conjunction 0x2522dd0, static_id: 2 + 11656278: cap 0: Create spark for conjunction: 0x2522dd0 spark: 0x24c + 11656462: cap 0: Start a parallel conjunction 0x2522e30, static_id: 2 + 11656602: cap 0: Create spark for conjunction: 0x2522e30 spark: 0x24d + 11656786: cap 0: Start a parallel conjunction 0x2522e90, static_id: 2 + 11656908: cap 0: Create spark for conjunction: 0x2522e90 spark: 0x24e + 11657097: cap 0: Start a parallel conjunction 0x2522ef0, static_id: 2 + 11657227: cap 0: Create spark for conjunction: 0x2522ef0 spark: 0x24f + 11657407: cap 0: Start a parallel conjunction 0x2522f50, static_id: 2 + 11657524: cap 0: Create spark for conjunction: 0x2522f50 spark: 0x250 + 11657857: cap 0: Start a parallel conjunction 0x2522fb0, static_id: 2 + 11657983: cap 0: Create spark for conjunction: 0x2522fb0 spark: 0x251 + 11658172: cap 0: Start a parallel conjunction 0x2523010, static_id: 2 + 11658294: cap 0: Create spark for conjunction: 0x2523010 spark: 0x252 + 11658487: cap 0: Start a parallel conjunction 0x2523070, static_id: 2 + 11658618: cap 0: Create spark for conjunction: 0x2523070 spark: 0x253 + 11658802: cap 0: Start a parallel conjunction 0x25230d0, static_id: 2 + 11658933: cap 0: Create spark for conjunction: 0x25230d0 spark: 0x254 + 11659126: cap 0: Start a parallel conjunction 0x2523130, static_id: 2 + 11659252: cap 0: Create spark for conjunction: 0x2523130 spark: 0x255 + 11659446: cap 0: Start a parallel conjunction 0x2523190, static_id: 2 + 11659567: cap 0: Create spark for conjunction: 0x2523190 spark: 0x256 + 11659752: cap 0: Start a parallel conjunction 0x25231f0, static_id: 2 + 11659896: cap 0: Create spark for conjunction: 0x25231f0 spark: 0x257 + 11660076: cap 0: Start a parallel conjunction 0x2523250, static_id: 2 + 11660202: cap 0: Create spark for conjunction: 0x2523250 spark: 0x258 + 11660395: cap 0: Start a parallel conjunction 0x25232b0, static_id: 2 + 11660530: cap 0: Create spark for conjunction: 0x25232b0 spark: 0x259 + 11660710: cap 0: Start a parallel conjunction 0x2523310, static_id: 2 + 11660832: cap 0: Create spark for conjunction: 0x2523310 spark: 0x25a + 11661183: cap 0: Start a parallel conjunction 0x2523370, static_id: 2 + 11661313: cap 0: Create spark for conjunction: 0x2523370 spark: 0x25b + 11661507: cap 0: Start a parallel conjunction 0x25233d0, static_id: 2 + 11661633: cap 0: Create spark for conjunction: 0x25233d0 spark: 0x25c + 11661813: cap 0: Start a parallel conjunction 0x2523430, static_id: 2 + 11661952: cap 0: Create spark for conjunction: 0x2523430 spark: 0x25d + 11662132: cap 0: Start a parallel conjunction 0x2523490, static_id: 2 + 11662254: cap 0: Create spark for conjunction: 0x2523490 spark: 0x25e + 11662447: cap 0: Start a parallel conjunction 0x25234f0, static_id: 2 + 11662573: cap 0: Create spark for conjunction: 0x25234f0 spark: 0x25f + 11662753: cap 0: Start a parallel conjunction 0x2523550, static_id: 2 + 11662875: cap 0: Create spark for conjunction: 0x2523550 spark: 0x260 + 11663059: cap 0: Start a parallel conjunction 0x25235b0, static_id: 2 + 11663190: cap 0: Create spark for conjunction: 0x25235b0 spark: 0x261 + 11663374: cap 0: Start a parallel conjunction 0x2523610, static_id: 2 + 11663500: cap 0: Create spark for conjunction: 0x2523610 spark: 0x262 + 11663689: cap 0: Start a parallel conjunction 0x2523670, static_id: 2 + 11663824: cap 0: Create spark for conjunction: 0x2523670 spark: 0x263 + 11664018: cap 0: Start a parallel conjunction 0x25236d0, static_id: 2 + 11664157: cap 0: Create spark for conjunction: 0x25236d0 spark: 0x264 + 11664346: cap 0: Start a parallel conjunction 0x2523730, static_id: 2 + 11664481: cap 0: Create spark for conjunction: 0x2523730 spark: 0x265 + 11664675: cap 0: Start a parallel conjunction 0x2523790, static_id: 2 + 11664801: cap 0: Create spark for conjunction: 0x2523790 spark: 0x266 + 11664985: cap 0: Start a parallel conjunction 0x25237f0, static_id: 2 + 11665116: cap 0: Create spark for conjunction: 0x25237f0 spark: 0x267 + 11665300: cap 0: Start a parallel conjunction 0x2523850, static_id: 2 + 11665422: cap 0: Create spark for conjunction: 0x2523850 spark: 0x268 + 11665611: cap 0: Start a parallel conjunction 0x25238b0, static_id: 2 + 11665741: cap 0: Create spark for conjunction: 0x25238b0 spark: 0x269 + 11665921: cap 0: Start a parallel conjunction 0x2523910, static_id: 2 + 11666047: cap 0: Create spark for conjunction: 0x2523910 spark: 0x26a + 11666232: cap 0: Start a parallel conjunction 0x2523970, static_id: 2 + 11666367: cap 0: Create spark for conjunction: 0x2523970 spark: 0x26b + 11666556: cap 0: Start a parallel conjunction 0x25239d0, static_id: 2 + 11666677: cap 0: Create spark for conjunction: 0x25239d0 spark: 0x26c + 11666862: cap 0: Start a parallel conjunction 0x2523a30, static_id: 2 + 11666997: cap 0: Create spark for conjunction: 0x2523a30 spark: 0x26d + 11667172: cap 0: Start a parallel conjunction 0x2523a90, static_id: 2 + 11667294: cap 0: Create spark for conjunction: 0x2523a90 spark: 0x26e + 11667483: cap 0: Start a parallel conjunction 0x2523af0, static_id: 2 + 11667609: cap 0: Create spark for conjunction: 0x2523af0 spark: 0x26f + 11667793: cap 0: Start a parallel conjunction 0x2523b50, static_id: 2 + 11667915: cap 0: Create spark for conjunction: 0x2523b50 spark: 0x270 + 11668099: cap 0: Start a parallel conjunction 0x2523bb0, static_id: 2 + 11668252: cap 0: Create spark for conjunction: 0x2523bb0 spark: 0x271 + 11668432: cap 0: Start a parallel conjunction 0x2523c10, static_id: 2 + 11668554: cap 0: Create spark for conjunction: 0x2523c10 spark: 0x272 + 11668747: cap 0: Start a parallel conjunction 0x2523c70, static_id: 2 + 11668878: cap 0: Create spark for conjunction: 0x2523c70 spark: 0x273 + 11669058: cap 0: Start a parallel conjunction 0x2523cd0, static_id: 2 + 11669193: cap 0: Create spark for conjunction: 0x2523cd0 spark: 0x274 + 11669391: cap 0: Start a parallel conjunction 0x2523d30, static_id: 2 + 11669521: cap 0: Create spark for conjunction: 0x2523d30 spark: 0x275 + 11669710: cap 0: Start a parallel conjunction 0x2523d90, static_id: 2 + 11669836: cap 0: Create spark for conjunction: 0x2523d90 spark: 0x276 + 11670021: cap 0: Start a parallel conjunction 0x2523df0, static_id: 2 + 11670160: cap 0: Create spark for conjunction: 0x2523df0 spark: 0x277 + 11670340: cap 0: Start a parallel conjunction 0x2523e50, static_id: 2 + 11670466: cap 0: Create spark for conjunction: 0x2523e50 spark: 0x278 + 11670660: cap 0: Start a parallel conjunction 0x2523eb0, static_id: 2 + 11670790: cap 0: Create spark for conjunction: 0x2523eb0 spark: 0x279 + 11670970: cap 0: Start a parallel conjunction 0x2523f10, static_id: 2 + 11671096: cap 0: Create spark for conjunction: 0x2523f10 spark: 0x27a + 11671281: cap 0: Start a parallel conjunction 0x2523f70, static_id: 2 + 11671411: cap 0: Create spark for conjunction: 0x2523f70 spark: 0x27b + 11671744: cap 0: Start a parallel conjunction 0x2523fd0, static_id: 2 + 11671870: cap 0: Create spark for conjunction: 0x2523fd0 spark: 0x27c + 11672298: cap 0: Start a parallel conjunction 0x2524030, static_id: 2 + 11672446: cap 0: Create spark for conjunction: 0x2524030 spark: 0x27d + 11672631: cap 0: Start a parallel conjunction 0x2524090, static_id: 2 + 11672752: cap 0: Create spark for conjunction: 0x2524090 spark: 0x27e + 11672941: cap 0: Start a parallel conjunction 0x25240f0, static_id: 2 + 11673076: cap 0: Create spark for conjunction: 0x25240f0 spark: 0x27f + 11673256: cap 0: Start a parallel conjunction 0x2524150, static_id: 2 + 11673382: cap 0: Create spark for conjunction: 0x2524150 spark: 0x280 + 11673567: cap 0: Start a parallel conjunction 0x25241b0, static_id: 2 + 11673697: cap 0: Create spark for conjunction: 0x25241b0 spark: 0x281 + 11673873: cap 0: Start a parallel conjunction 0x2524210, static_id: 2 + 11673994: cap 0: Create spark for conjunction: 0x2524210 spark: 0x282 + 11674183: cap 0: Start a parallel conjunction 0x2524270, static_id: 2 + 11674318: cap 0: Create spark for conjunction: 0x2524270 spark: 0x283 + 11674503: cap 0: Start a parallel conjunction 0x25242d0, static_id: 2 + 11674674: cap 0: Create spark for conjunction: 0x25242d0 spark: 0x284 + 11674867: cap 0: Start a parallel conjunction 0x2524330, static_id: 2 + 11675002: cap 0: Create spark for conjunction: 0x2524330 spark: 0x285 + 11675196: cap 0: Start a parallel conjunction 0x2524390, static_id: 2 + 11675317: cap 0: Create spark for conjunction: 0x2524390 spark: 0x286 + 11675493: cap 0: Start a parallel conjunction 0x25243f0, static_id: 2 + 11675632: cap 0: Create spark for conjunction: 0x25243f0 spark: 0x287 + 11675817: cap 0: Start a parallel conjunction 0x2524450, static_id: 2 + 11675983: cap 0: Create spark for conjunction: 0x2524450 spark: 0x288 + 11676190: cap 0: Start a parallel conjunction 0x25244b0, static_id: 2 + 11676321: cap 0: Create spark for conjunction: 0x25244b0 spark: 0x289 + 11676505: cap 0: Start a parallel conjunction 0x2524510, static_id: 2 + 11676789: cap 0: Create spark for conjunction: 0x2524510 spark: 0x28a + 11676969: cap 0: Start a parallel conjunction 0x2524570, static_id: 2 + 11677131: cap 0: Create spark for conjunction: 0x2524570 spark: 0x28b + 11677720: cap 0: Start a parallel conjunction 0x25245d0, static_id: 2 + 11677842: cap 0: Create spark for conjunction: 0x25245d0 spark: 0x28c + 11678026: cap 0: Start a parallel conjunction 0x2524630, static_id: 2 + 11678166: cap 0: Create spark for conjunction: 0x2524630 spark: 0x28d + 11678346: cap 0: Start a parallel conjunction 0x2524690, static_id: 2 + 11678467: cap 0: Create spark for conjunction: 0x2524690 spark: 0x28e + 11678652: cap 0: Start a parallel conjunction 0x25246f0, static_id: 2 + 11678782: cap 0: Create spark for conjunction: 0x25246f0 spark: 0x28f + 11678967: cap 0: Start a parallel conjunction 0x2524750, static_id: 2 + 11679088: cap 0: Create spark for conjunction: 0x2524750 spark: 0x290 + 11679268: cap 0: Start a parallel conjunction 0x25247b0, static_id: 2 + 11679399: cap 0: Create spark for conjunction: 0x25247b0 spark: 0x291 + 11679583: cap 0: Start a parallel conjunction 0x2524810, static_id: 2 + 11679714: cap 0: Create spark for conjunction: 0x2524810 spark: 0x292 + 11679912: cap 0: Start a parallel conjunction 0x2524870, static_id: 2 + 11680042: cap 0: Create spark for conjunction: 0x2524870 spark: 0x293 + 11680231: cap 0: Start a parallel conjunction 0x25248d0, static_id: 2 + 11680366: cap 0: Create spark for conjunction: 0x25248d0 spark: 0x294 + 11680564: cap 0: Start a parallel conjunction 0x2524930, static_id: 2 + 11680695: cap 0: Create spark for conjunction: 0x2524930 spark: 0x295 + 11680888: cap 0: Start a parallel conjunction 0x2524990, static_id: 2 + 11681014: cap 0: Create spark for conjunction: 0x2524990 spark: 0x296 + 11681199: cap 0: Start a parallel conjunction 0x25249f0, static_id: 2 + 11681338: cap 0: Create spark for conjunction: 0x25249f0 spark: 0x297 + 11681518: cap 0: Start a parallel conjunction 0x2524a50, static_id: 2 + 11681644: cap 0: Create spark for conjunction: 0x2524a50 spark: 0x298 + 11681833: cap 0: Start a parallel conjunction 0x2524ab0, static_id: 2 + 11681959: cap 0: Create spark for conjunction: 0x2524ab0 spark: 0x299 + 11682139: cap 0: Start a parallel conjunction 0x2524b10, static_id: 2 + 11682261: cap 0: Create spark for conjunction: 0x2524b10 spark: 0x29a + 11682445: cap 0: Start a parallel conjunction 0x2524b70, static_id: 2 + 11682576: cap 0: Create spark for conjunction: 0x2524b70 spark: 0x29b + 11682760: cap 0: Start a parallel conjunction 0x2524bd0, static_id: 2 + 11682886: cap 0: Create spark for conjunction: 0x2524bd0 spark: 0x29c + 11683062: cap 0: Start a parallel conjunction 0x2524c30, static_id: 2 + 11683206: cap 0: Create spark for conjunction: 0x2524c30 spark: 0x29d + 11683386: cap 0: Start a parallel conjunction 0x2524c90, static_id: 2 + 11683512: cap 0: Create spark for conjunction: 0x2524c90 spark: 0x29e + 11683705: cap 0: Start a parallel conjunction 0x2524cf0, static_id: 2 + 11683836: cap 0: Create spark for conjunction: 0x2524cf0 spark: 0x29f + 11684011: cap 0: Start a parallel conjunction 0x2524d50, static_id: 2 + 11684133: cap 0: Create spark for conjunction: 0x2524d50 spark: 0x2a0 + 11684317: cap 0: Start a parallel conjunction 0x2524db0, static_id: 2 + 11684448: cap 0: Create spark for conjunction: 0x2524db0 spark: 0x2a1 + 11684628: cap 0: Start a parallel conjunction 0x2524e10, static_id: 2 + 11684749: cap 0: Create spark for conjunction: 0x2524e10 spark: 0x2a2 + 11684938: cap 0: Start a parallel conjunction 0x2524e70, static_id: 2 + 11685073: cap 0: Create spark for conjunction: 0x2524e70 spark: 0x2a3 + 11685253: cap 0: Start a parallel conjunction 0x2524ed0, static_id: 2 + 11685388: cap 0: Create spark for conjunction: 0x2524ed0 spark: 0x2a4 + 11685577: cap 0: Start a parallel conjunction 0x2524f30, static_id: 2 + 11685712: cap 0: Create spark for conjunction: 0x2524f30 spark: 0x2a5 + 11685901: cap 0: Start a parallel conjunction 0x2524f90, static_id: 2 + 11686027: cap 0: Create spark for conjunction: 0x2524f90 spark: 0x2a6 + 11686554: cap 0: Start a parallel conjunction 0x2524ff0, static_id: 2 + 11686693: cap 0: Create spark for conjunction: 0x2524ff0 spark: 0x2a7 + 11686882: cap 0: Start a parallel conjunction 0x2525050, static_id: 2 + 11687008: cap 0: Create spark for conjunction: 0x2525050 spark: 0x2a8 + 11687202: cap 0: Start a parallel conjunction 0x25250b0, static_id: 2 + 11687332: cap 0: Create spark for conjunction: 0x25250b0 spark: 0x2a9 + 11687512: cap 0: Start a parallel conjunction 0x2525110, static_id: 2 + 11687643: cap 0: Create spark for conjunction: 0x2525110 spark: 0x2aa + 11687827: cap 0: Start a parallel conjunction 0x2525170, static_id: 2 + 11687953: cap 0: Create spark for conjunction: 0x2525170 spark: 0x2ab + 11688142: cap 0: Start a parallel conjunction 0x25251d0, static_id: 2 + 11688264: cap 0: Create spark for conjunction: 0x25251d0 spark: 0x2ac + 11688448: cap 0: Start a parallel conjunction 0x2525230, static_id: 2 + 11688583: cap 0: Create spark for conjunction: 0x2525230 spark: 0x2ad + 11688763: cap 0: Start a parallel conjunction 0x2525290, static_id: 2 + 11688885: cap 0: Create spark for conjunction: 0x2525290 spark: 0x2ae + 11689074: cap 0: Start a parallel conjunction 0x25252f0, static_id: 2 + 11689209: cap 0: Create spark for conjunction: 0x25252f0 spark: 0x2af + 11689389: cap 0: Start a parallel conjunction 0x2525350, static_id: 2 + 11689510: cap 0: Create spark for conjunction: 0x2525350 spark: 0x2b0 + 11689695: cap 0: Start a parallel conjunction 0x25253b0, static_id: 2 + 11689825: cap 0: Create spark for conjunction: 0x25253b0 spark: 0x2b1 + 11690005: cap 0: Start a parallel conjunction 0x2525410, static_id: 2 + 11690131: cap 0: Create spark for conjunction: 0x2525410 spark: 0x2b2 + 11690325: cap 0: Start a parallel conjunction 0x2525470, static_id: 2 + 11690455: cap 0: Create spark for conjunction: 0x2525470 spark: 0x2b3 + 11690631: cap 0: Start a parallel conjunction 0x25254d0, static_id: 2 + 11690766: cap 0: Create spark for conjunction: 0x25254d0 spark: 0x2b4 + 11690955: cap 0: Start a parallel conjunction 0x2525530, static_id: 2 + 11691090: cap 0: Create spark for conjunction: 0x2525530 spark: 0x2b5 + 11691279: cap 0: Start a parallel conjunction 0x2525590, static_id: 2 + 11691405: cap 0: Create spark for conjunction: 0x2525590 spark: 0x2b6 + 11691585: cap 0: Start a parallel conjunction 0x25255f0, static_id: 2 + 11691724: cap 0: Create spark for conjunction: 0x25255f0 spark: 0x2b7 + 11691904: cap 0: Start a parallel conjunction 0x2525650, static_id: 2 + 11692026: cap 0: Create spark for conjunction: 0x2525650 spark: 0x2b8 + 11692233: cap 0: Start a parallel conjunction 0x25256b0, static_id: 2 + 11692363: cap 0: Create spark for conjunction: 0x25256b0 spark: 0x2b9 + 11692539: cap 0: Start a parallel conjunction 0x2525710, static_id: 2 + 11692665: cap 0: Create spark for conjunction: 0x2525710 spark: 0x2ba + 11692849: cap 0: Start a parallel conjunction 0x2525770, static_id: 2 + 11692975: cap 0: Create spark for conjunction: 0x2525770 spark: 0x2bb + 11693164: cap 0: Start a parallel conjunction 0x25257d0, static_id: 2 + 11693290: cap 0: Create spark for conjunction: 0x25257d0 spark: 0x2bc + 11693475: cap 0: Start a parallel conjunction 0x2525830, static_id: 2 + 11693610: cap 0: Create spark for conjunction: 0x2525830 spark: 0x2bd + 11693794: cap 0: Start a parallel conjunction 0x2525890, static_id: 2 + 11693916: cap 0: Create spark for conjunction: 0x2525890 spark: 0x2be + 11694127: cap 0: Start a parallel conjunction 0x25258f0, static_id: 2 + 11694258: cap 0: Create spark for conjunction: 0x25258f0 spark: 0x2bf + 11694438: cap 0: Start a parallel conjunction 0x2525950, static_id: 2 + 11694564: cap 0: Create spark for conjunction: 0x2525950 spark: 0x2c0 + 11694753: cap 0: Start a parallel conjunction 0x25259b0, static_id: 2 + 11694892: cap 0: Create spark for conjunction: 0x25259b0 spark: 0x2c1 + 11695081: cap 0: Start a parallel conjunction 0x2525a10, static_id: 2 + 11695203: cap 0: Create spark for conjunction: 0x2525a10 spark: 0x2c2 + 11695401: cap 0: Start a parallel conjunction 0x2525a70, static_id: 2 + 11695531: cap 0: Create spark for conjunction: 0x2525a70 spark: 0x2c3 + 11695711: cap 0: Start a parallel conjunction 0x2525ad0, static_id: 2 + 11695842: cap 0: Create spark for conjunction: 0x2525ad0 spark: 0x2c4 + 11696031: cap 0: Start a parallel conjunction 0x2525b30, static_id: 2 + 11696161: cap 0: Create spark for conjunction: 0x2525b30 spark: 0x2c5 + 11696350: cap 0: Start a parallel conjunction 0x2525b90, static_id: 2 + 11696476: cap 0: Create spark for conjunction: 0x2525b90 spark: 0x2c6 + 11696656: cap 0: Start a parallel conjunction 0x2525bf0, static_id: 2 + 11696791: cap 0: Create spark for conjunction: 0x2525bf0 spark: 0x2c7 + 11696980: cap 0: Start a parallel conjunction 0x2525c50, static_id: 2 + 11697106: cap 0: Create spark for conjunction: 0x2525c50 spark: 0x2c8 + 11697300: cap 0: Start a parallel conjunction 0x2525cb0, static_id: 2 + 11697435: cap 0: Create spark for conjunction: 0x2525cb0 spark: 0x2c9 + 11697615: cap 0: Start a parallel conjunction 0x2525d10, static_id: 2 + 11697741: cap 0: Create spark for conjunction: 0x2525d10 spark: 0x2ca + 11697925: cap 0: Start a parallel conjunction 0x2525d70, static_id: 2 + 11698060: cap 0: Create spark for conjunction: 0x2525d70 spark: 0x2cb + 11698249: cap 0: Start a parallel conjunction 0x2525dd0, static_id: 2 + 11698380: cap 0: Create spark for conjunction: 0x2525dd0 spark: 0x2cc + 11698560: cap 0: Start a parallel conjunction 0x2525e30, static_id: 2 + 11698699: cap 0: Create spark for conjunction: 0x2525e30 spark: 0x2cd + 11698888: cap 0: Start a parallel conjunction 0x2525e90, static_id: 2 + 11699014: cap 0: Create spark for conjunction: 0x2525e90 spark: 0x2ce + 11699221: cap 0: Start a parallel conjunction 0x2525ef0, static_id: 2 + 11699356: cap 0: Create spark for conjunction: 0x2525ef0 spark: 0x2cf + 11699536: cap 0: Start a parallel conjunction 0x2525f50, static_id: 2 + 11699662: cap 0: Create spark for conjunction: 0x2525f50 spark: 0x2d0 + 11700009: cap 0: Start a parallel conjunction 0x2525fb0, static_id: 2 + 11700139: cap 0: Create spark for conjunction: 0x2525fb0 spark: 0x2d1 + 11700432: cap 0: Start a parallel conjunction 0x2526010, static_id: 2 + 11700558: cap 0: Create spark for conjunction: 0x2526010 spark: 0x2d2 + 11700751: cap 0: Start a parallel conjunction 0x2526070, static_id: 2 + 11700882: cap 0: Create spark for conjunction: 0x2526070 spark: 0x2d3 + 11701057: cap 0: Start a parallel conjunction 0x25260d0, static_id: 2 + 11701183: cap 0: Create spark for conjunction: 0x25260d0 spark: 0x2d4 + 11701372: cap 0: Start a parallel conjunction 0x2526130, static_id: 2 + 11701503: cap 0: Create spark for conjunction: 0x2526130 spark: 0x2d5 + 11701692: cap 0: Start a parallel conjunction 0x2526190, static_id: 2 + 11701818: cap 0: Create spark for conjunction: 0x2526190 spark: 0x2d6 + 11702133: cap 0: Start a parallel conjunction 0x25261f0, static_id: 2 + 11702272: cap 0: Create spark for conjunction: 0x25261f0 spark: 0x2d7 + 11702457: cap 0: Start a parallel conjunction 0x2526250, static_id: 2 + 11702578: cap 0: Create spark for conjunction: 0x2526250 spark: 0x2d8 + 11702763: cap 0: Start a parallel conjunction 0x25262b0, static_id: 2 + 11702893: cap 0: Create spark for conjunction: 0x25262b0 spark: 0x2d9 + 11703073: cap 0: Start a parallel conjunction 0x2526310, static_id: 2 + 11703199: cap 0: Create spark for conjunction: 0x2526310 spark: 0x2da + 11703384: cap 0: Start a parallel conjunction 0x2526370, static_id: 2 + 11703510: cap 0: Create spark for conjunction: 0x2526370 spark: 0x2db + 11703825: cap 0: Start a parallel conjunction 0x25263d0, static_id: 2 + 11703946: cap 0: Create spark for conjunction: 0x25263d0 spark: 0x2dc + 11704140: cap 0: Start a parallel conjunction 0x2526430, static_id: 2 + 11704275: cap 0: Create spark for conjunction: 0x2526430 spark: 0x2dd + 11704455: cap 0: Start a parallel conjunction 0x2526490, static_id: 2 + 11704576: cap 0: Create spark for conjunction: 0x2526490 spark: 0x2de + 11704761: cap 0: Start a parallel conjunction 0x25264f0, static_id: 2 + 11704891: cap 0: Create spark for conjunction: 0x25264f0 spark: 0x2df + 11705067: cap 0: Start a parallel conjunction 0x2526550, static_id: 2 + 11705188: cap 0: Create spark for conjunction: 0x2526550 spark: 0x2e0 + 11705373: cap 0: Start a parallel conjunction 0x25265b0, static_id: 2 + 11705499: cap 0: Create spark for conjunction: 0x25265b0 spark: 0x2e1 + 11705683: cap 0: Start a parallel conjunction 0x2526610, static_id: 2 + 11705814: cap 0: Create spark for conjunction: 0x2526610 spark: 0x2e2 + 11706003: cap 0: Start a parallel conjunction 0x2526670, static_id: 2 + 11706133: cap 0: Create spark for conjunction: 0x2526670 spark: 0x2e3 + 11706318: cap 0: Start a parallel conjunction 0x25266d0, static_id: 2 + 11706448: cap 0: Create spark for conjunction: 0x25266d0 spark: 0x2e4 + 11706642: cap 0: Start a parallel conjunction 0x2526730, static_id: 2 + 11706777: cap 0: Create spark for conjunction: 0x2526730 spark: 0x2e5 + 11706966: cap 0: Start a parallel conjunction 0x2526790, static_id: 2 + 11707092: cap 0: Create spark for conjunction: 0x2526790 spark: 0x2e6 + 11707272: cap 0: Start a parallel conjunction 0x25267f0, static_id: 2 + 11707551: cap 0: Create spark for conjunction: 0x25267f0 spark: 0x2e7 + 11707744: cap 0: Start a parallel conjunction 0x2526850, static_id: 2 + 11707866: cap 0: Create spark for conjunction: 0x2526850 spark: 0x2e8 + 11708185: cap 0: Start a parallel conjunction 0x25268b0, static_id: 2 + 11708316: cap 0: Create spark for conjunction: 0x25268b0 spark: 0x2e9 + 11708505: cap 0: Start a parallel conjunction 0x2526910, static_id: 2 + 11708626: cap 0: Create spark for conjunction: 0x2526910 spark: 0x2ea + 11708811: cap 0: Start a parallel conjunction 0x2526970, static_id: 2 + 11708937: cap 0: Create spark for conjunction: 0x2526970 spark: 0x2eb + 11709126: cap 0: Start a parallel conjunction 0x25269d0, static_id: 2 + 11709247: cap 0: Create spark for conjunction: 0x25269d0 spark: 0x2ec + 11709427: cap 0: Start a parallel conjunction 0x2526a30, static_id: 2 + 11709562: cap 0: Create spark for conjunction: 0x2526a30 spark: 0x2ed + 11709742: cap 0: Start a parallel conjunction 0x2526a90, static_id: 2 + 11709864: cap 0: Create spark for conjunction: 0x2526a90 spark: 0x2ee + 11710062: cap 0: Start a parallel conjunction 0x2526af0, static_id: 2 + 11710197: cap 0: Create spark for conjunction: 0x2526af0 spark: 0x2ef + 11710372: cap 0: Start a parallel conjunction 0x2526b50, static_id: 2 + 11710503: cap 0: Create spark for conjunction: 0x2526b50 spark: 0x2f0 + 11710696: cap 0: Start a parallel conjunction 0x2526bb0, static_id: 2 + 11710827: cap 0: Create spark for conjunction: 0x2526bb0 spark: 0x2f1 + 11711011: cap 0: Start a parallel conjunction 0x2526c10, static_id: 2 + 11711128: cap 0: Create spark for conjunction: 0x2526c10 spark: 0x2f2 + 11711322: cap 0: Start a parallel conjunction 0x2526c70, static_id: 2 + 11711457: cap 0: Create spark for conjunction: 0x2526c70 spark: 0x2f3 + 11711637: cap 0: Start a parallel conjunction 0x2526cd0, static_id: 2 + 11711763: cap 0: Create spark for conjunction: 0x2526cd0 spark: 0x2f4 + 11711952: cap 0: Start a parallel conjunction 0x2526d30, static_id: 2 + 11712082: cap 0: Create spark for conjunction: 0x2526d30 spark: 0x2f5 + 11712271: cap 0: Start a parallel conjunction 0x2526d90, static_id: 2 + 11712397: cap 0: Create spark for conjunction: 0x2526d90 spark: 0x2f6 + 11712577: cap 0: Start a parallel conjunction 0x2526df0, static_id: 2 + 11712712: cap 0: Create spark for conjunction: 0x2526df0 spark: 0x2f7 + 11712888: cap 0: Start a parallel conjunction 0x2526e50, static_id: 2 + 11713009: cap 0: Create spark for conjunction: 0x2526e50 spark: 0x2f8 + 11713198: cap 0: Start a parallel conjunction 0x2526eb0, static_id: 2 + 11713329: cap 0: Create spark for conjunction: 0x2526eb0 spark: 0x2f9 + 11713504: cap 0: Start a parallel conjunction 0x2526f10, static_id: 2 + 11713626: cap 0: Create spark for conjunction: 0x2526f10 spark: 0x2fa + 11713810: cap 0: Start a parallel conjunction 0x2526f70, static_id: 2 + 11713936: cap 0: Create spark for conjunction: 0x2526f70 spark: 0x2fb + 11714130: cap 0: Start a parallel conjunction 0x2526fd0, static_id: 2 + 11714256: cap 0: Create spark for conjunction: 0x2526fd0 spark: 0x2fc + 11714463: cap 0: Start a parallel conjunction 0x2527030, static_id: 2 + 11714598: cap 0: Create spark for conjunction: 0x2527030 spark: 0x2fd + 11714787: cap 0: Start a parallel conjunction 0x2527090, static_id: 2 + 11714908: cap 0: Create spark for conjunction: 0x2527090 spark: 0x2fe + 11715097: cap 0: Start a parallel conjunction 0x25270f0, static_id: 2 + 11715223: cap 0: Create spark for conjunction: 0x25270f0 spark: 0x2ff + 11715403: cap 0: Start a parallel conjunction 0x2527150, static_id: 2 + 11715525: cap 0: Create spark for conjunction: 0x2527150 spark: 0x300 + 11715705: cap 0: Start a parallel conjunction 0x25271b0, static_id: 2 + 11715835: cap 0: Create spark for conjunction: 0x25271b0 spark: 0x301 + 11716015: cap 0: Start a parallel conjunction 0x2527210, static_id: 2 + 11716137: cap 0: Create spark for conjunction: 0x2527210 spark: 0x302 + 11716321: cap 0: Start a parallel conjunction 0x2527270, static_id: 2 + 11716452: cap 0: Create spark for conjunction: 0x2527270 spark: 0x303 + 11716632: cap 0: Start a parallel conjunction 0x25272d0, static_id: 2 + 11716803: cap 0: Create spark for conjunction: 0x25272d0 spark: 0x304 + 11716987: cap 0: Start a parallel conjunction 0x2527330, static_id: 2 + 11717113: cap 0: Create spark for conjunction: 0x2527330 spark: 0x305 + 11717302: cap 0: Start a parallel conjunction 0x2527390, static_id: 2 + 11717424: cap 0: Create spark for conjunction: 0x2527390 spark: 0x306 + 11717604: cap 0: Start a parallel conjunction 0x25273f0, static_id: 2 + 11717743: cap 0: Create spark for conjunction: 0x25273f0 spark: 0x307 + 11717919: cap 0: Start a parallel conjunction 0x2527450, static_id: 2 + 11718085: cap 0: Create spark for conjunction: 0x2527450 spark: 0x308 + 11718288: cap 0: Start a parallel conjunction 0x25274b0, static_id: 2 + 11718418: cap 0: Create spark for conjunction: 0x25274b0 spark: 0x309 + 11718594: cap 0: Start a parallel conjunction 0x2527510, static_id: 2 + 11718720: cap 0: Create spark for conjunction: 0x2527510 spark: 0x30a + 11718904: cap 0: Start a parallel conjunction 0x2527570, static_id: 2 + 11719035: cap 0: Create spark for conjunction: 0x2527570 spark: 0x30b + 11719219: cap 0: Start a parallel conjunction 0x25275d0, static_id: 2 + 11719341: cap 0: Create spark for conjunction: 0x25275d0 spark: 0x30c + 11719525: cap 0: Start a parallel conjunction 0x2527630, static_id: 2 + 11719669: cap 0: Create spark for conjunction: 0x2527630 spark: 0x30d + 11719849: cap 0: Start a parallel conjunction 0x2527690, static_id: 2 + 11719971: cap 0: Create spark for conjunction: 0x2527690 spark: 0x30e + 11720155: cap 0: Start a parallel conjunction 0x25276f0, static_id: 2 + 11720290: cap 0: Create spark for conjunction: 0x25276f0 spark: 0x30f + 11720475: cap 0: Start a parallel conjunction 0x2527750, static_id: 2 + 11720601: cap 0: Create spark for conjunction: 0x2527750 spark: 0x310 + 11720776: cap 0: Start a parallel conjunction 0x25277b0, static_id: 2 + 11720907: cap 0: Create spark for conjunction: 0x25277b0 spark: 0x311 + 11721087: cap 0: Start a parallel conjunction 0x2527810, static_id: 2 + 11721204: cap 0: Create spark for conjunction: 0x2527810 spark: 0x312 + 11721393: cap 0: Start a parallel conjunction 0x2527870, static_id: 2 + 11721528: cap 0: Create spark for conjunction: 0x2527870 spark: 0x313 + 11721708: cap 0: Start a parallel conjunction 0x25278d0, static_id: 2 + 11721834: cap 0: Create spark for conjunction: 0x25278d0 spark: 0x314 + 11722149: cap 0: Start a parallel conjunction 0x2527930, static_id: 2 + 11722275: cap 0: Create spark for conjunction: 0x2527930 spark: 0x315 + 11722464: cap 0: Start a parallel conjunction 0x2527990, static_id: 2 + 11722590: cap 0: Create spark for conjunction: 0x2527990 spark: 0x316 + 11722770: cap 0: Start a parallel conjunction 0x25279f0, static_id: 2 + 11722905: cap 0: Create spark for conjunction: 0x25279f0 spark: 0x317 + 11723089: cap 0: Start a parallel conjunction 0x2527a50, static_id: 2 + 11723215: cap 0: Create spark for conjunction: 0x2527a50 spark: 0x318 + 11723400: cap 0: Start a parallel conjunction 0x2527ab0, static_id: 2 + 11723535: cap 0: Create spark for conjunction: 0x2527ab0 spark: 0x319 + 11723715: cap 0: Start a parallel conjunction 0x2527b10, static_id: 2 + 11723836: cap 0: Create spark for conjunction: 0x2527b10 spark: 0x31a + 11724021: cap 0: Start a parallel conjunction 0x2527b70, static_id: 2 + 11724151: cap 0: Create spark for conjunction: 0x2527b70 spark: 0x31b + 11724340: cap 0: Start a parallel conjunction 0x2527bd0, static_id: 2 + 11724462: cap 0: Create spark for conjunction: 0x2527bd0 spark: 0x31c + 11724642: cap 0: Start a parallel conjunction 0x2527c30, static_id: 2 + 11724781: cap 0: Create spark for conjunction: 0x2527c30 spark: 0x31d + 11724961: cap 0: Start a parallel conjunction 0x2527c90, static_id: 2 + 11725092: cap 0: Create spark for conjunction: 0x2527c90 spark: 0x31e + 11725285: cap 0: Start a parallel conjunction 0x2527cf0, static_id: 2 + 11725425: cap 0: Create spark for conjunction: 0x2527cf0 spark: 0x31f + 11728597: cap 0: End par conjunct: 0x2527cf0 + 11730312: cap 0: running a local spark + 12148717: cap 3: creating spark thread 3 + 12149284: cap 3: running thread 3 + 12335386: cap 2: creating spark thread 2 + 12336304: cap 2: running thread 2 + 12609625: cap 1: creating spark thread 4 + 12610075: cap 1: running thread 4 + 12877888: cap 3: End par conjunct: 0x25151b0 + 12878455: cap 3: Trying to steal a spark + 12879013: cap 3: stealing a spark from cap 0 + 13341195: cap 2: End par conjunct: 0x2515150 + 13342090: cap 2: Trying to steal a spark + 13343094: cap 2: stealing a spark from cap 0 + 13501534: cap 3: End par conjunct: 0x2515270 + 13501827: cap 3: Trying to steal a spark + 13502322: cap 3: stealing a spark from cap 0 + 13596930: cap 1: End par conjunct: 0x2515210 + 13597681: cap 1: Trying to steal a spark + 13598401: cap 1: stealing a spark from cap 0 + 14083335: cap 1: stopping thread 4 (heap overflow) + 14083542: cap 1: starting GC + 14136727: cap 0: stopping thread 1 (thread yielding) + 14140219: cap 3: stopping thread 3 (thread yielding) + 14149165: cap 2: stopping thread 2 (thread yielding) + 23736676: cap 0: running thread 1 + 23740087: cap 3: running thread 3 + 23748079: cap 2: running thread 2 + 23783076: cap 1: finished GC + 23783292: cap 1: running thread 4 + 24076197: cap 2: End par conjunct: 0x25152d0 + 24078132: cap 2: Trying to steal a spark + 24079986: cap 2: stealing a spark from cap 0 + 24232905: cap 3: End par conjunct: 0x2515330 + 24233566: cap 3: Trying to steal a spark + 24234601: cap 3: stealing a spark from cap 0 + 24254811: cap 1: End par conjunct: 0x2515390 + 24255621: cap 1: Trying to steal a spark + 24256161: cap 1: stealing a spark from cap 0 + 24726721: cap 2: End par conjunct: 0x25153f0 + 24726996: cap 2: Trying to steal a spark + 24727351: cap 2: stealing a spark from cap 0 + 24884374: cap 1: End par conjunct: 0x25154b0 + 24884775: cap 1: Trying to steal a spark + 24884995: cap 1: stealing a spark from cap 0 + 25181676: cap 3: End par conjunct: 0x2515450 + 25182256: cap 3: Trying to steal a spark + 25182837: cap 3: stealing a spark from cap 0 + 25332556: cap 2: End par conjunct: 0x2515510 + 25332939: cap 2: Trying to steal a spark + 25333330: cap 2: stealing a spark from cap 0 + 25496014: cap 1: End par conjunct: 0x2515570 + 25496253: cap 1: Trying to steal a spark + 25496473: cap 1: stealing a spark from cap 0 + 25927915: cap 2: End par conjunct: 0x2515630 + 25928122: cap 2: Trying to steal a spark + 25928334: cap 2: stealing a spark from cap 0 + 26084745: cap 3: End par conjunct: 0x25155d0 + 26085249: cap 3: Trying to steal a spark + 26085843: cap 3: stealing a spark from cap 0 + 26090298: cap 1: End par conjunct: 0x2515690 + 26090689: cap 1: Trying to steal a spark + 26091085: cap 1: stealing a spark from cap 0 + 26536383: cap 2: End par conjunct: 0x25156f0 + 26536603: cap 2: Trying to steal a spark + 26536914: cap 2: stealing a spark from cap 0 + 26692762: cap 1: End par conjunct: 0x25157b0 + 26692992: cap 1: Trying to steal a spark + 26693203: cap 1: stealing a spark from cap 0 + 26979043: cap 3: End par conjunct: 0x2515750 + 26979642: cap 3: Trying to steal a spark + 26980258: cap 3: stealing a spark from cap 0 + 27137002: cap 2: End par conjunct: 0x2515810 + 27137416: cap 2: Trying to steal a spark + 27137952: cap 2: stealing a spark from cap 0 + 27307827: cap 1: End par conjunct: 0x2515870 + 27308056: cap 1: Trying to steal a spark + 27308272: cap 1: stealing a spark from cap 0 + 27746244: cap 2: End par conjunct: 0x2515930 + 27746469: cap 2: Trying to steal a spark + 27746680: cap 2: stealing a spark from cap 0 + 27876528: cap 3: End par conjunct: 0x25158d0 + 27877045: cap 3: Trying to steal a spark + 27877761: cap 3: stealing a spark from cap 0 + 27921861: cap 1: End par conjunct: 0x2515990 + 27922432: cap 1: Trying to steal a spark + 27922869: cap 1: stealing a spark from cap 0 + 28351957: cap 2: End par conjunct: 0x25159f0 + 28352187: cap 2: Trying to steal a spark + 28352407: cap 2: stealing a spark from cap 0 + 28533199: cap 1: End par conjunct: 0x2515ab0 + 28533424: cap 1: Trying to steal a spark + 28533631: cap 1: stealing a spark from cap 0 + 28780488: cap 3: End par conjunct: 0x2515a50 + 28780996: cap 3: Trying to steal a spark + 28781604: cap 3: stealing a spark from cap 0 + 28984594: cap 2: End par conjunct: 0x2515b10 + 28985049: cap 2: Trying to steal a spark + 28985485: cap 2: stealing a spark from cap 0 + 29173518: cap 1: End par conjunct: 0x2515b70 + 29173806: cap 1: Trying to steal a spark + 29174062: cap 1: stealing a spark from cap 0 + 29588274: cap 2: End par conjunct: 0x2515c30 + 29588494: cap 2: Trying to steal a spark + 29588706: cap 2: stealing a spark from cap 0 + 29705886: cap 3: End par conjunct: 0x2515bd0 + 29706475: cap 3: Trying to steal a spark + 29707047: cap 3: stealing a spark from cap 0 + 29788911: cap 1: End par conjunct: 0x2515c90 + 29789302: cap 1: Trying to steal a spark + 29789694: cap 1: stealing a spark from cap 0 + 30185464: cap 2: End par conjunct: 0x2515cf0 + 30185671: cap 2: Trying to steal a spark + 30185982: cap 2: stealing a spark from cap 0 + 30392149: cap 1: End par conjunct: 0x2515db0 + 30392374: cap 1: Trying to steal a spark + 30392590: cap 1: stealing a spark from cap 0 + 30611209: cap 3: End par conjunct: 0x2515d50 + 30611916: cap 3: Trying to steal a spark + 30612640: cap 3: stealing a spark from cap 0 + 30809916: cap 2: End par conjunct: 0x2515e10 + 30810312: cap 2: Trying to steal a spark + 30810712: cap 2: stealing a spark from cap 0 + 31008384: cap 1: End par conjunct: 0x2515e70 + 31008600: cap 1: Trying to steal a spark + 31008901: cap 1: stealing a spark from cap 0 + 31420368: cap 2: End par conjunct: 0x2515f30 + 31420593: cap 2: Trying to steal a spark + 31420809: cap 2: stealing a spark from cap 0 + 31533394: cap 3: End par conjunct: 0x2515ed0 + 31533984: cap 3: Trying to steal a spark + 31534591: cap 3: stealing a spark from cap 0 + 31615168: cap 1: End par conjunct: 0x2515f90 + 31615596: cap 1: Trying to steal a spark + 31615992: cap 1: stealing a spark from cap 0 + 32033641: cap 2: End par conjunct: 0x2515ff0 + 32033866: cap 2: Trying to steal a spark + 32034177: cap 2: stealing a spark from cap 0 + 32268591: cap 1: End par conjunct: 0x25160b0 + 32268874: cap 1: Trying to steal a spark + 32269131: cap 1: stealing a spark from cap 0 + 32468868: cap 3: End par conjunct: 0x2516050 + 32469426: cap 3: Trying to steal a spark + 32470078: cap 3: stealing a spark from cap 0 + 32677348: cap 2: End par conjunct: 0x2516110 + 32677776: cap 2: Trying to steal a spark + 32678208: cap 2: stealing a spark from cap 0 + 32876379: cap 1: End par conjunct: 0x2516170 + 32876590: cap 1: Trying to steal a spark + 32876811: cap 1: stealing a spark from cap 0 + 33304153: cap 2: End par conjunct: 0x2516230 + 33304374: cap 2: Trying to steal a spark + 33304684: cap 2: stealing a spark from cap 0 + 33398968: cap 3: End par conjunct: 0x25161d0 + 33399441: cap 3: Trying to steal a spark + 33399936: cap 3: stealing a spark from cap 0 + 33498414: cap 1: End par conjunct: 0x2516290 + 33498900: cap 1: Trying to steal a spark + 33499372: cap 1: stealing a spark from cap 0 + 33926773: cap 2: End par conjunct: 0x25162f0 + 33927003: cap 2: Trying to steal a spark + 33927219: cap 2: stealing a spark from cap 0 + 34125759: cap 1: End par conjunct: 0x25163b0 + 34125984: cap 1: Trying to steal a spark + 34126200: cap 1: stealing a spark from cap 0 + 34343518: cap 3: End par conjunct: 0x2516350 + 34344018: cap 3: Trying to steal a spark + 34344841: cap 3: stealing a spark from cap 0 + 34555158: cap 2: End par conjunct: 0x2516410 + 34555585: cap 2: Trying to steal a spark + 34555999: cap 2: stealing a spark from cap 0 + 34755426: cap 1: End par conjunct: 0x2516470 + 34755651: cap 1: Trying to steal a spark + 34755885: cap 1: stealing a spark from cap 0 + 35181679: cap 2: End par conjunct: 0x2516530 + 35181904: cap 2: Trying to steal a spark + 35182219: cap 2: stealing a spark from cap 0 + 35299462: cap 3: End par conjunct: 0x25164d0 + 35300011: cap 3: Trying to steal a spark + 35300614: cap 3: stealing a spark from cap 0 + 35403894: cap 1: End par conjunct: 0x2516590 + 35404425: cap 1: Trying to steal a spark + 35404992: cap 1: stealing a spark from cap 0 + 35817421: cap 2: End par conjunct: 0x25165f0 + 35817651: cap 2: Trying to steal a spark + 35817867: cap 2: stealing a spark from cap 0 + 36025614: cap 1: End par conjunct: 0x25166b0 + 36025843: cap 1: Trying to steal a spark + 36026055: cap 1: stealing a spark from cap 0 + 36222511: cap 3: End par conjunct: 0x2516650 + 36223024: cap 3: Trying to steal a spark + 36223618: cap 3: stealing a spark from cap 0 + 36455044: cap 2: End par conjunct: 0x2516710 + 36455602: cap 2: Trying to steal a spark + 36456102: cap 2: stealing a spark from cap 0 + 36668988: cap 1: End par conjunct: 0x2516770 + 36669204: cap 1: Trying to steal a spark + 36669415: cap 1: stealing a spark from cap 0 + 37113880: cap 2: End par conjunct: 0x2516830 + 37114330: cap 2: Trying to steal a spark + 37114650: cap 2: stealing a spark from cap 0 + 37175854: cap 3: End par conjunct: 0x25167d0 + 37176363: cap 3: Trying to steal a spark + 37176957: cap 3: stealing a spark from cap 0 + 37328764: cap 1: End par conjunct: 0x2516890 + 37329291: cap 1: Trying to steal a spark + 37329781: cap 1: stealing a spark from cap 0 + 37769184: cap 2: End par conjunct: 0x25168f0 + 37769454: cap 2: Trying to steal a spark + 37769818: cap 2: stealing a spark from cap 0 + 37969281: cap 1: End par conjunct: 0x25169b0 + 37969506: cap 1: Trying to steal a spark + 37969722: cap 1: stealing a spark from cap 0 + 38118726: cap 3: End par conjunct: 0x2516950 + 38119275: cap 3: Trying to steal a spark + 38119873: cap 3: stealing a spark from cap 0 + 38409223: cap 2: End par conjunct: 0x2516a10 + 38409628: cap 2: Trying to steal a spark + 38410029: cap 2: stealing a spark from cap 0 + 38624274: cap 1: End par conjunct: 0x2516a70 + 38624539: cap 1: Trying to steal a spark + 38624760: cap 1: stealing a spark from cap 0 + 39093678: cap 2: End par conjunct: 0x2516b30 + 39093957: cap 2: Trying to steal a spark + 39094204: cap 2: stealing a spark from cap 0 + 39133138: cap 3: End par conjunct: 0x2516ad0 + 39133723: cap 3: Trying to steal a spark + 39134574: cap 3: stealing a spark from cap 0 + 39276504: cap 1: End par conjunct: 0x2516b90 + 39276913: cap 1: Trying to steal a spark + 39277332: cap 1: stealing a spark from cap 0 + 39746497: cap 2: End par conjunct: 0x2516bf0 + 39746718: cap 2: Trying to steal a spark + 39746938: cap 2: stealing a spark from cap 0 + 39951765: cap 1: End par conjunct: 0x2516cb0 + 39952062: cap 1: Trying to steal a spark + 39952341: cap 1: stealing a spark from cap 0 + 40113454: cap 3: End par conjunct: 0x2516c50 + 40113999: cap 3: Trying to steal a spark + 40114507: cap 3: stealing a spark from cap 0 + 40408366: cap 2: End par conjunct: 0x2516d10 + 40408816: cap 2: Trying to steal a spark + 40409239: cap 2: stealing a spark from cap 0 + 40619043: cap 1: End par conjunct: 0x2516d70 + 40619268: cap 1: Trying to steal a spark + 40619488: cap 1: stealing a spark from cap 0 + 41067765: cap 2: End par conjunct: 0x2516e30 + 41068017: cap 2: Trying to steal a spark + 41068260: cap 2: stealing a spark from cap 0 + 41114754: cap 3: End par conjunct: 0x2516dd0 + 41115456: cap 3: Trying to steal a spark + 41116095: cap 3: stealing a spark from cap 0 + 41283873: cap 1: End par conjunct: 0x2516e90 + 41284156: cap 1: Trying to steal a spark + 41284548: cap 1: stealing a spark from cap 0 + 41730048: cap 2: End par conjunct: 0x2516ef0 + 41730273: cap 2: Trying to steal a spark + 41730583: cap 2: stealing a spark from cap 0 + 41952546: cap 1: End par conjunct: 0x2516fb0 + 41952771: cap 1: Trying to steal a spark + 41952982: cap 1: stealing a spark from cap 0 + 42100420: cap 3: End par conjunct: 0x2516f50 + 42100924: cap 3: Trying to steal a spark + 42101577: cap 3: stealing a spark from cap 0 + 42400962: cap 2: End par conjunct: 0x2517010 + 42401286: cap 2: Trying to steal a spark + 42401709: cap 2: stealing a spark from cap 0 + 42633526: cap 1: End par conjunct: 0x2517070 + 42633801: cap 1: Trying to steal a spark + 42634035: cap 1: stealing a spark from cap 0 + 43071579: cap 2: End par conjunct: 0x2517130 + 43071804: cap 2: Trying to steal a spark + 43072141: cap 2: stealing a spark from cap 0 + 43098408: cap 3: End par conjunct: 0x25170d0 + 43099047: cap 3: Trying to steal a spark + 43099650: cap 3: stealing a spark from cap 0 + 43299085: cap 1: End par conjunct: 0x2517190 + 43299540: cap 1: Trying to steal a spark + 43299994: cap 1: stealing a spark from cap 0 + 43749342: cap 2: End par conjunct: 0x25171f0 + 43749675: cap 2: Trying to steal a spark + 43749981: cap 2: stealing a spark from cap 0 + 43987482: cap 1: End par conjunct: 0x25172b0 + 43987711: cap 1: Trying to steal a spark + 43987927: cap 1: stealing a spark from cap 0 + 44106511: cap 3: End par conjunct: 0x2517250 + 44107020: cap 3: Trying to steal a spark + 44107524: cap 3: stealing a spark from cap 0 + 44435862: cap 2: End par conjunct: 0x2517310 + 44436258: cap 2: Trying to steal a spark + 44436654: cap 2: stealing a spark from cap 0 + 44685877: cap 1: End par conjunct: 0x2517370 + 44686093: cap 1: Trying to steal a spark + 44686305: cap 1: stealing a spark from cap 0 + 45133911: cap 2: End par conjunct: 0x2517430 + 45134136: cap 2: Trying to steal a spark + 45134446: cap 2: stealing a spark from cap 0 + 45154615: cap 3: End par conjunct: 0x25173d0 + 45155164: cap 3: Trying to steal a spark + 45155763: cap 3: stealing a spark from cap 0 + 45397935: cap 1: End par conjunct: 0x2517490 + 45398326: cap 1: Trying to steal a spark + 45398718: cap 1: stealing a spark from cap 0 + 45836001: cap 2: End par conjunct: 0x25174f0 + 45836226: cap 2: Trying to steal a spark + 45836541: cap 2: stealing a spark from cap 0 + 46110154: cap 1: End par conjunct: 0x25175b0 + 46110379: cap 1: Trying to steal a spark + 46110595: cap 1: stealing a spark from cap 0 + 46221808: cap 3: End par conjunct: 0x2517550 + 46222308: cap 3: Trying to steal a spark + 46222902: cap 3: stealing a spark from cap 0 + 46588792: cap 2: End par conjunct: 0x2517610 + 46589211: cap 2: Trying to steal a spark + 46589625: cap 2: stealing a spark from cap 0 + 46844860: cap 1: End par conjunct: 0x2517670 + 46845072: cap 1: Trying to steal a spark + 46845288: cap 1: stealing a spark from cap 0 + 47312941: cap 2: End par conjunct: 0x2517730 + 47313166: cap 2: Trying to steal a spark + 47313477: cap 2: stealing a spark from cap 0 + 47330820: cap 3: End par conjunct: 0x25176d0 + 47331400: cap 3: Trying to steal a spark + 47332035: cap 3: stealing a spark from cap 0 + 47604280: cap 1: End par conjunct: 0x2517790 + 47604735: cap 1: Trying to steal a spark + 47605203: cap 1: stealing a spark from cap 0 + 48060094: cap 2: End par conjunct: 0x25177f0 + 48060297: cap 2: Trying to steal a spark + 48060603: cap 2: stealing a spark from cap 0 + 48358003: cap 1: End par conjunct: 0x25178b0 + 48358228: cap 1: Trying to steal a spark + 48358458: cap 1: stealing a spark from cap 0 + 48437491: cap 3: End par conjunct: 0x2517850 + 48437964: cap 3: Trying to steal a spark + 48438558: cap 3: stealing a spark from cap 0 + 48805825: cap 2: End par conjunct: 0x2517910 + 48806239: cap 2: Trying to steal a spark + 48806824: cap 2: stealing a spark from cap 0 + 49100440: cap 1: End par conjunct: 0x2517970 + 49100665: cap 1: Trying to steal a spark + 49100886: cap 1: stealing a spark from cap 0 + 49579861: cap 3: End par conjunct: 0x25179d0 + 49580419: cap 3: Trying to steal a spark + 49581022: cap 3: stealing a spark from cap 0 + 49636854: cap 2: End par conjunct: 0x2517a30 + 49637754: cap 2: Trying to steal a spark + 49638730: cap 2: stealing a spark from cap 0 + 49870381: cap 1: End par conjunct: 0x2517a90 + 49870705: cap 1: Trying to steal a spark + 49870917: cap 1: stealing a spark from cap 0 + 50426550: cap 2: End par conjunct: 0x2517b50 + 50426932: cap 2: Trying to steal a spark + 50427261: cap 2: stealing a spark from cap 0 + 50665230: cap 1: End par conjunct: 0x2517bb0 + 50665441: cap 1: Trying to steal a spark + 50665653: cap 1: stealing a spark from cap 0 + 50830560: cap 3: End par conjunct: 0x2517af0 + 50831068: cap 3: Trying to steal a spark + 50831662: cap 3: stealing a spark from cap 0 + 51224148: cap 2: End par conjunct: 0x2517c10 + 51224454: cap 2: Trying to steal a spark + 51225012: cap 2: stealing a spark from cap 0 + 51483465: cap 1: End par conjunct: 0x2517c70 + 51483685: cap 1: Trying to steal a spark + 51483906: cap 1: stealing a spark from cap 0 + 52064626: cap 3: End par conjunct: 0x2517cd0 + 52065135: cap 3: Trying to steal a spark + 52065729: cap 3: stealing a spark from cap 0 + 52247997: cap 2: End par conjunct: 0x2517d30 + 52248433: cap 2: Trying to steal a spark + 52248924: cap 2: stealing a spark from cap 0 + 52314489: cap 1: End par conjunct: 0x2517d90 + 52314921: cap 1: Trying to steal a spark + 52315168: cap 1: stealing a spark from cap 0 + 53089573: cap 2: End par conjunct: 0x2517e50 + 53089983: cap 2: Trying to steal a spark + 53090334: cap 2: stealing a spark from cap 0 + 53148744: cap 1: End par conjunct: 0x2517eb0 + 53148991: cap 1: Trying to steal a spark + 53149203: cap 1: stealing a spark from cap 0 + 53306419: cap 3: End par conjunct: 0x2517df0 + 53306928: cap 3: Trying to steal a spark + 53307544: cap 3: stealing a spark from cap 0 + 53907304: cap 2: End par conjunct: 0x2517f10 + 53907579: cap 2: Trying to steal a spark + 53907961: cap 2: stealing a spark from cap 0 + 54013536: cap 1: End par conjunct: 0x2517f70 + 54013806: cap 1: Trying to steal a spark + 54014022: cap 1: stealing a spark from cap 0 + 54337927: cap 3: End par conjunct: 0x2517fd0 + 54338431: cap 3: Trying to steal a spark + 54338931: cap 3: stealing a spark from cap 0 + 54762241: cap 2: End par conjunct: 0x2518030 + 54762664: cap 2: Trying to steal a spark + 54763177: cap 2: stealing a spark from cap 0 + 54909072: cap 1: End par conjunct: 0x2518090 + 54909450: cap 1: Trying to steal a spark + 54909684: cap 1: stealing a spark from cap 0 + 55878903: cap 2: End par conjunct: 0x2518150 + 55879249: cap 2: Trying to steal a spark + 55879465: cap 2: stealing a spark from cap 0 + 55923277: cap 3: End par conjunct: 0x25180f0 + 55923610: cap 3: Trying to steal a spark + 55924101: cap 3: stealing a spark from cap 0 + 56954371: cap 1: End par conjunct: 0x25181b0 + 56954632: cap 1: Trying to steal a spark + 56955096: cap 1: stealing a spark from cap 0 + 58131936: cap 2: End par conjunct: 0x2518210 + 58132260: cap 2: Trying to steal a spark + 58132476: cap 2: stealing a spark from cap 0 + 58232556: cap 3: End par conjunct: 0x2518270 + 58232889: cap 3: Trying to steal a spark + 58233262: cap 3: stealing a spark from cap 0 + 59230395: cap 1: End par conjunct: 0x25182d0 + 59231034: cap 1: Trying to steal a spark + 59231439: cap 1: stealing a spark from cap 0 + 59402803: cap 3: End par conjunct: 0x2518390 + 59403244: cap 3: Trying to steal a spark + 59403739: cap 3: stealing a spark from cap 0 + 59775511: cap 2: End par conjunct: 0x2518330 + 59775781: cap 2: Trying to steal a spark + 59776168: cap 2: stealing a spark from cap 0 + 60382269: cap 3: End par conjunct: 0x2518450 + 60382647: cap 3: Trying to steal a spark + 60383133: cap 3: stealing a spark from cap 0 + 60445363: cap 1: End par conjunct: 0x25183f0 + 60445737: cap 1: Trying to steal a spark + 60446155: cap 1: stealing a spark from cap 0 + 61507039: cap 2: End par conjunct: 0x25184b0 + 61507665: cap 2: Trying to steal a spark + 61508101: cap 2: stealing a spark from cap 0 + 62346784: cap 1: End par conjunct: 0x2518570 + 62347000: cap 1: Trying to steal a spark + 62347216: cap 1: stealing a spark from cap 0 + 62512888: cap 3: End par conjunct: 0x2518510 + 62513284: cap 3: Trying to steal a spark + 62513658: cap 3: stealing a spark from cap 0 + 63392238: cap 2: End par conjunct: 0x25185d0 + 63392625: cap 2: Trying to steal a spark + 63393111: cap 2: stealing a spark from cap 0 + 63590472: cap 3: End par conjunct: 0x2518690 + 63590904: cap 3: Trying to steal a spark + 63591385: cap 3: stealing a spark from cap 0 + 64123029: cap 1: End par conjunct: 0x2518630 + 64123375: cap 1: Trying to steal a spark + 64123893: cap 1: stealing a spark from cap 0 + 64477633: cap 2: End par conjunct: 0x25186f0 + 64477975: cap 2: Trying to steal a spark + 64478223: cap 2: stealing a spark from cap 0 + 64722933: cap 3: End par conjunct: 0x2518750 + 64723369: cap 3: Trying to steal a spark + 64723851: cap 3: stealing a spark from cap 0 + 65542941: cap 1: End par conjunct: 0x25187b0 + 65543301: cap 1: Trying to steal a spark + 65543782: cap 1: stealing a spark from cap 0 + 65650234: cap 2: End par conjunct: 0x2518810 + 65650576: cap 2: Trying to steal a spark + 65650788: cap 2: stealing a spark from cap 0 + 66578935: cap 3: End par conjunct: 0x2518870 + 66579484: cap 3: Trying to steal a spark + 66580056: cap 3: stealing a spark from cap 0 + 66854529: cap 2: End par conjunct: 0x2518930 + 66854853: cap 2: Trying to steal a spark + 66855343: cap 2: stealing a spark from cap 0 + 66946320: cap 1: End par conjunct: 0x25188d0 + 66946707: cap 1: Trying to steal a spark + 66946963: cap 1: stealing a spark from cap 0 + 67733041: cap 3: End par conjunct: 0x2518990 + 67733455: cap 3: Trying to steal a spark + 67733950: cap 3: stealing a spark from cap 0 + 68058499: cap 2: End par conjunct: 0x25189f0 + 68058882: cap 2: Trying to steal a spark + 68059377: cap 2: stealing a spark from cap 0 + 68678649: cap 1: End par conjunct: 0x2518a50 + 68678982: cap 1: Trying to steal a spark + 68679229: cap 1: stealing a spark from cap 0 + 69240861: cap 3: End par conjunct: 0x2518ab0 + 69241176: cap 3: Trying to steal a spark + 69241567: cap 3: stealing a spark from cap 0 + 69304954: cap 2: End par conjunct: 0x2518b10 + 69305319: cap 2: Trying to steal a spark + 69305692: cap 2: stealing a spark from cap 0 + 70140240: cap 1: End par conjunct: 0x2518b70 + 70140469: cap 1: Trying to steal a spark + 70140685: cap 1: stealing a spark from cap 0 + 70773511: cap 3: End par conjunct: 0x2518bd0 + 70773885: cap 3: Trying to steal a spark + 70774366: cap 3: stealing a spark from cap 0 + 70808850: cap 2: End par conjunct: 0x2518c30 + 70809367: cap 2: Trying to steal a spark + 70809768: cap 2: stealing a spark from cap 0 + 71873527: cap 1: End par conjunct: 0x2518c90 + 71873860: cap 1: Trying to steal a spark + 71874072: cap 1: stealing a spark from cap 0 + 72283689: cap 2: End par conjunct: 0x2518d50 + 72284017: cap 2: Trying to steal a spark + 72284233: cap 2: stealing a spark from cap 0 + 73054251: cap 3: End par conjunct: 0x2518cf0 + 73054732: cap 3: Trying to steal a spark + 73055466: cap 3: stealing a spark from cap 0 + 73159285: cap 1: End par conjunct: 0x2518db0 + 73159722: cap 1: Trying to steal a spark + 73160388: cap 1: stealing a spark from cap 0 + 74440966: cap 3: End par conjunct: 0x2518e70 + 74441227: cap 3: Trying to steal a spark + 74441610: cap 3: stealing a spark from cap 0 + 74785315: cap 2: End par conjunct: 0x2518e10 + 74786017: cap 2: Trying to steal a spark + 74787043: cap 2: stealing a spark from cap 0 + 75288483: cap 1: End par conjunct: 0x2518ed0 + 75288820: cap 1: Trying to steal a spark + 75289032: cap 1: stealing a spark from cap 0 + 77436747: cap 3: End par conjunct: 0x2518f30 + 77437134: cap 3: Trying to steal a spark + 77437759: cap 3: stealing a spark from cap 0 + 78004147: cap 2: End par conjunct: 0x2518f90 + 78004602: cap 2: Trying to steal a spark + 78005169: cap 2: stealing a spark from cap 0 + 78438784: cap 1: End par conjunct: 0x2518ff0 + 78439081: cap 1: Trying to steal a spark + 78439360: cap 1: stealing a spark from cap 0 + 80926996: cap 3: End par conjunct: 0x2519050 + 80927392: cap 3: Trying to steal a spark + 80927775: cap 3: stealing a spark from cap 0 + 82047559: cap 2: End par conjunct: 0x25190b0 + 82047987: cap 2: Trying to steal a spark + 82048459: cap 2: stealing a spark from cap 0 + 83968875: cap 1: End par conjunct: 0x2519110 + 83969217: cap 1: Trying to steal a spark + 83969428: cap 1: stealing a spark from cap 0 + 86729665: cap 3: End par conjunct: 0x2519170 + 86730021: cap 3: Trying to steal a spark + 86730417: cap 3: stealing a spark from cap 0 + 88351767: cap 2: End par conjunct: 0x25191d0 + 88352401: cap 2: Trying to steal a spark + 88353040: cap 2: stealing a spark from cap 0 + 91559997: cap 1: End par conjunct: 0x2519230 + 91560532: cap 1: Trying to steal a spark + 91560888: cap 1: stealing a spark from cap 0 + 94191606: cap 3: End par conjunct: 0x2519290 + 94192038: cap 3: Trying to steal a spark + 94192447: cap 3: stealing a spark from cap 0 + 96909921: cap 2: End par conjunct: 0x25192f0 + 96910249: cap 2: Trying to steal a spark + 96910677: cap 2: stealing a spark from cap 0 +101435247: cap 1: End par conjunct: 0x2519350 +101435656: cap 1: Trying to steal a spark +101435913: cap 1: stealing a spark from cap 0 +106433743: cap 3: End par conjunct: 0x25193b0 +106434189: cap 3: Trying to steal a spark +106434796: cap 3: stealing a spark from cap 0 +109706557: cap 2: End par conjunct: 0x2519410 +109707070: cap 2: Trying to steal a spark +109707538: cap 2: stealing a spark from cap 0 +114820515: cap 1: End par conjunct: 0x2519470 +114820857: cap 1: Trying to steal a spark +114821217: cap 1: stealing a spark from cap 0 +119917665: cap 3: End par conjunct: 0x25194d0 +119918088: cap 3: Trying to steal a spark +119918511: cap 3: stealing a spark from cap 0 +123108241: cap 2: End par conjunct: 0x2519530 +123108687: cap 2: Trying to steal a spark +123109312: cap 2: stealing a spark from cap 0 +128630704: cap 1: End par conjunct: 0x2519590 +128631078: cap 1: Trying to steal a spark +128631334: cap 1: stealing a spark from cap 0 +134686683: cap 3: End par conjunct: 0x25195f0 +134687052: cap 3: Trying to steal a spark +134687601: cap 3: stealing a spark from cap 0 +137862301: cap 2: End par conjunct: 0x2519650 +137862945: cap 2: Trying to steal a spark +137863800: cap 2: stealing a spark from cap 0 +144241731: cap 1: End par conjunct: 0x25196b0 +144242343: cap 1: Trying to steal a spark +144242730: cap 1: stealing a spark from cap 0 +151251367: cap 3: End par conjunct: 0x2519710 +151251804: cap 3: Trying to steal a spark +151252218: cap 3: stealing a spark from cap 0 +156148578: cap 2: End par conjunct: 0x2519770 +156149059: cap 2: Trying to steal a spark +156149635: cap 2: stealing a spark from cap 0 +164802690: cap 1: End par conjunct: 0x25197d0 +164803180: cap 1: Trying to steal a spark +164803441: cap 1: stealing a spark from cap 0 +172408338: cap 3: End par conjunct: 0x2519830 +172408693: cap 3: Trying to steal a spark +172409116: cap 3: stealing a spark from cap 0 +178849849: cap 2: End par conjunct: 0x2519890 +178850839: cap 2: Trying to steal a spark +178851514: cap 2: stealing a spark from cap 0 +190023232: cap 1: End par conjunct: 0x25198f0 +190023628: cap 1: Trying to steal a spark +190024060: cap 1: stealing a spark from cap 0 +198545305: cap 3: End par conjunct: 0x2519950 +198545724: cap 3: Trying to steal a spark +198546151: cap 3: stealing a spark from cap 0 +198953811: cap 0: End par conjunct: 0x2527cf0 +198958869: cap 0: End par conjunction: 0x2527cf0 +198959206: cap 0: End par conjunct: 0x2527c90 +198959832: cap 0: running a local spark +204747844: cap 2: End par conjunct: 0x25199b0 +204748560: cap 2: Trying to steal a spark +204749253: cap 2: stealing a spark from cap 0 +216975420: cap 1: End par conjunct: 0x2519a10 +216976068: cap 1: Trying to steal a spark +216976392: cap 1: stealing a spark from cap 0 +226126588: cap 3: End par conjunct: 0x2519a70 +226127047: cap 3: Trying to steal a spark +226127484: cap 3: stealing a spark from cap 0 +231747502: cap 2: End par conjunct: 0x2519ad0 +231747970: cap 2: Trying to steal a spark +231748443: cap 2: stealing a spark from cap 0 +247099896: cap 1: End par conjunct: 0x2519b30 +247100737: cap 1: Trying to steal a spark +247101367: cap 1: stealing a spark from cap 0 +255828780: cap 3: End par conjunct: 0x2519b90 +255829216: cap 3: Trying to steal a spark +255829729: cap 3: stealing a spark from cap 0 +260583750: cap 2: End par conjunct: 0x2519bf0 +260584209: cap 2: Trying to steal a spark +260584807: cap 2: stealing a spark from cap 0 +274906435: cap 1: End par conjunct: 0x2519c50 +274906827: cap 1: Trying to steal a spark +274907083: cap 1: stealing a spark from cap 0 +284926387: cap 3: End par conjunct: 0x2519cb0 +284926752: cap 3: Trying to steal a spark +284927184: cap 3: stealing a spark from cap 0 +290982267: cap 2: End par conjunct: 0x2519d10 +290983005: cap 2: Trying to steal a spark +290983702: cap 2: stealing a spark from cap 0 +307252908: cap 1: End par conjunct: 0x2519d70 +307253191: cap 1: Trying to steal a spark +307253569: cap 1: stealing a spark from cap 0 +319299286: cap 3: End par conjunct: 0x2519dd0 +319299700: cap 3: Trying to steal a spark +319300159: cap 3: stealing a spark from cap 0 +326048778: cap 2: End par conjunct: 0x2519e30 +326049336: cap 2: Trying to steal a spark +326049898: cap 2: stealing a spark from cap 0 +350669619: cap 1: End par conjunct: 0x2519e90 +350670901: cap 1: Trying to steal a spark +350671846: cap 1: stealing a spark from cap 0 +358029666: cap 3: End par conjunct: 0x2519ef0 +358030057: cap 3: Trying to steal a spark +358030525: cap 3: stealing a spark from cap 0 +364705011: cap 2: End par conjunct: 0x2519f50 +364706158: cap 2: Trying to steal a spark +364706928: cap 2: stealing a spark from cap 0 +365778837: cap 0: End par conjunct: 0x2527c90 +365779084: cap 0: End par conjunction: 0x2527c90 +365779363: cap 0: End par conjunct: 0x2527c30 +365779795: cap 0: running a local spark +391049748: cap 1: End par conjunct: 0x2519fb0 +391050117: cap 1: Trying to steal a spark +391050733: cap 1: stealing a spark from cap 0 +397728738: cap 3: End par conjunct: 0x251a010 +397729296: cap 3: Trying to steal a spark +397729710: cap 3: stealing a spark from cap 0 +403134480: cap 2: End par conjunct: 0x251a070 +403134916: cap 2: Trying to steal a spark +403135398: cap 2: stealing a spark from cap 0 +430105333: cap 1: End par conjunct: 0x251a0d0 +430105828: cap 1: Trying to steal a spark +430106098: cap 1: stealing a spark from cap 0 +436262724: cap 3: End par conjunct: 0x251a130 +436263097: cap 3: Trying to steal a spark +436263556: cap 3: stealing a spark from cap 0 +441701977: cap 2: End par conjunct: 0x251a190 +441702540: cap 2: Trying to steal a spark +441703102: cap 2: stealing a spark from cap 0 +471085258: cap 1: End par conjunct: 0x251a1f0 +471085825: cap 1: Trying to steal a spark +471086374: cap 1: stealing a spark from cap 0 +477770602: cap 3: End par conjunct: 0x251a250 +477771034: cap 3: Trying to steal a spark +477771471: cap 3: stealing a spark from cap 0 +484487622: cap 2: End par conjunct: 0x251a2b0 +484488301: cap 2: Trying to steal a spark +484488778: cap 2: stealing a spark from cap 0 +514659478: cap 1: End par conjunct: 0x251a310 +514659942: cap 1: Trying to steal a spark +514660297: cap 1: stealing a spark from cap 0 +521906107: cap 3: End par conjunct: 0x251a370 +521906481: cap 3: Trying to steal a spark +521906908: cap 3: stealing a spark from cap 0 +529207344: cap 2: End par conjunct: 0x251a3d0 +529207843: cap 2: Trying to steal a spark +529208352: cap 2: stealing a spark from cap 0 +531944473: cap 0: End par conjunct: 0x2527c30 +531944712: cap 0: End par conjunction: 0x2527c30 +531944883: cap 0: End par conjunct: 0x2527bd0 +531945387: cap 0: running a local spark +562630792: cap 1: End par conjunct: 0x251a430 +562631112: cap 1: Trying to steal a spark +562631571: cap 1: stealing a spark from cap 0 +570400015: cap 3: End par conjunct: 0x251a490 +570400758: cap 3: Trying to steal a spark +570401365: cap 3: stealing a spark from cap 0 +576937926: cap 2: End par conjunct: 0x251a4f0 +576938331: cap 2: Trying to steal a spark +576938812: cap 2: stealing a spark from cap 0 +612735025: cap 1: End par conjunct: 0x251a550 +612735705: cap 1: Trying to steal a spark +612736429: cap 1: stealing a spark from cap 0 +619791169: cap 3: End par conjunct: 0x251a5b0 +619791552: cap 3: Trying to steal a spark +619792128: cap 3: stealing a spark from cap 0 +626189926: cap 2: End par conjunct: 0x251a610 +626190583: cap 2: Trying to steal a spark +626191096: cap 2: stealing a spark from cap 0 +663484621: cap 1: End par conjunct: 0x251a670 +663484909: cap 1: Trying to steal a spark +663485238: cap 1: stealing a spark from cap 0 +671033749: cap 3: End par conjunct: 0x251a6d0 +671034276: cap 3: Trying to steal a spark +671034811: cap 3: stealing a spark from cap 0 +677780014: cap 2: End par conjunct: 0x251a730 +677780779: cap 2: Trying to steal a spark +677781445: cap 2: stealing a spark from cap 0 +699230403: cap 0: End par conjunct: 0x2527bd0 +699230659: cap 0: End par conjunction: 0x2527bd0 +699230835: cap 0: End par conjunct: 0x2527b70 +699231397: cap 0: running a local spark +717773436: cap 1: End par conjunct: 0x251a790 +717774057: cap 1: Trying to steal a spark +717774921: cap 1: stealing a spark from cap 0 +726011095: cap 3: End par conjunct: 0x251a7f0 +726011635: cap 3: Trying to steal a spark +726012076: cap 3: stealing a spark from cap 0 +730991659: cap 2: End par conjunct: 0x251a850 +730992199: cap 2: Trying to steal a spark +730992726: cap 2: stealing a spark from cap 0 +774688756: cap 1: End par conjunct: 0x251a8b0 +774689584: cap 1: Trying to steal a spark +774690183: cap 1: stealing a spark from cap 0 +781757100: cap 3: End par conjunct: 0x251a910 +781757734: cap 3: Trying to steal a spark +781758225: cap 3: stealing a spark from cap 0 +785501482: cap 2: End par conjunct: 0x251a970 +785502193: cap 2: Trying to steal a spark +785502751: cap 2: stealing a spark from cap 0 +829932813: cap 1: End par conjunct: 0x251a9d0 +829933366: cap 1: Trying to steal a spark +829933677: cap 1: stealing a spark from cap 0 +837245920: cap 3: End par conjunct: 0x251aa30 +837246307: cap 3: Trying to steal a spark +837246870: cap 3: stealing a spark from cap 0 +842193072: cap 2: End par conjunct: 0x251aa90 +842193535: cap 2: Trying to steal a spark +842193999: cap 2: stealing a spark from cap 0 +865855660: cap 0: End par conjunct: 0x2527b70 +865855854: cap 0: End par conjunction: 0x2527b70 +865856250: cap 0: End par conjunct: 0x2527b10 +865856655: cap 0: running a local spark +891740749: cap 1: End par conjunct: 0x251aaf0 +891741532: cap 1: Trying to steal a spark +891742756: cap 1: stealing a spark from cap 0 +899877420: cap 3: End par conjunct: 0x251ab50 +899877951: cap 3: Trying to steal a spark +899878387: cap 3: stealing a spark from cap 0 +904794669: cap 2: End par conjunct: 0x251abb0 +904795731: cap 2: Trying to steal a spark +904796541: cap 2: stealing a spark from cap 0 +956212956: cap 1: End par conjunct: 0x251ac10 +956213617: cap 1: Trying to steal a spark +956213982: cap 1: stealing a spark from cap 0 +965154496: cap 3: End par conjunct: 0x251ac70 +965154946: cap 3: Trying to steal a spark +965155464: cap 3: stealing a spark from cap 0 +968214550: cap 2: End par conjunct: 0x251acd0 +968215018: cap 2: Trying to steal a spark +968215549: cap 2: stealing a spark from cap 0 +1023491304: cap 1: End par conjunct: 0x251ad30 +1023492051: cap 1: Trying to steal a spark +1023492964: cap 1: stealing a spark from cap 0 +1033080210: cap 0: End par conjunct: 0x2527b10 +1033080399: cap 0: End par conjunction: 0x2527b10 +1033080588: cap 0: End par conjunct: 0x2527ab0 +1033080961: cap 0: running a local spark +1033241377: cap 3: End par conjunct: 0x251ad90 +1033241832: cap 3: Trying to steal a spark +1033242088: cap 3: stealing a spark from cap 0 +1035608773: cap 2: End par conjunct: 0x251adf0 +1035609259: cap 2: Trying to steal a spark +1035609754: cap 2: stealing a spark from cap 0 +1094081674: cap 1: End par conjunct: 0x251ae50 +1094082358: cap 1: Trying to steal a spark +1094083029: cap 1: stealing a spark from cap 0 +1104048639: cap 3: End par conjunct: 0x251aeb0 +1104049210: cap 3: Trying to steal a spark +1104049710: cap 3: stealing a spark from cap 0 +1106189802: cap 2: End par conjunct: 0x251af10 +1106190369: cap 2: Trying to steal a spark +1106190873: cap 2: stealing a spark from cap 0 +1166137375: cap 1: End par conjunct: 0x251af70 +1166138239: cap 1: Trying to steal a spark +1166138883: cap 1: stealing a spark from cap 0 +1176810660: cap 2: End par conjunct: 0x251b030 +1176811240: cap 2: Trying to steal a spark +1176811735: cap 2: stealing a spark from cap 0 +1176898396: cap 3: End par conjunct: 0x251afd0 +1176898900: cap 3: Trying to steal a spark +1176899553: cap 3: stealing a spark from cap 0 +1200629866: cap 0: End par conjunct: 0x2527ab0 +1200630069: cap 0: End par conjunction: 0x2527ab0 +1200630375: cap 0: End par conjunct: 0x2527a50 +1200630640: cap 0: running a local spark +1240834045: cap 1: End par conjunct: 0x251b090 +1240834689: cap 1: Trying to steal a spark +1240835539: cap 1: stealing a spark from cap 0 +1250312490: cap 2: End par conjunct: 0x251b0f0 +1250312809: cap 2: Trying to steal a spark +1250313336: cap 2: stealing a spark from cap 0 +1252791828: cap 3: End par conjunct: 0x251b150 +1252792251: cap 3: Trying to steal a spark +1252792773: cap 3: stealing a spark from cap 0 +1279191181: cap 1: stopping thread 4 (heap overflow) +1279191564: cap 1: starting GC +1279219414: cap 0: stopping thread 1 (thread yielding) +1279228891: cap 3: stopping thread 3 (thread yielding) +1279232685: cap 2: stopping thread 2 (thread yielding) +1288309455: cap 3: running thread 3 +1288309464: cap 0: running thread 1 +1288379502: cap 2: running thread 2 +1288653435: cap 1: finished GC +1288653723: cap 1: running thread 4 +1327831524: cap 1: End par conjunct: 0x251b1b0 +1327833261: cap 1: Trying to steal a spark +1327835277: cap 1: stealing a spark from cap 0 +1336238419: cap 2: End par conjunct: 0x251b210 +1336239922: cap 2: Trying to steal a spark +1336240854: cap 2: stealing a spark from cap 0 +1342275511: cap 3: End par conjunct: 0x251b270 +1342276861: cap 3: Trying to steal a spark +1342278328: cap 3: stealing a spark from cap 0 +1377233797: cap 0: End par conjunct: 0x2527a50 +1377234085: cap 0: End par conjunction: 0x2527a50 +1377234360: cap 0: End par conjunct: 0x25279f0 +1377234999: cap 0: running a local spark +1411012053: cap 1: End par conjunct: 0x251b2d0 +1411012948: cap 1: Trying to steal a spark +1411014010: cap 1: stealing a spark from cap 0 +1416178687: cap 2: End par conjunct: 0x251b330 +1416179236: cap 2: Trying to steal a spark +1416179596: cap 2: stealing a spark from cap 0 +1425281166: cap 3: End par conjunct: 0x251b390 +1425281638: cap 3: Trying to steal a spark +1425282160: cap 3: stealing a spark from cap 0 +1495637941: cap 1: End par conjunct: 0x251b3f0 +1495639008: cap 1: Trying to steal a spark +1495639872: cap 1: stealing a spark from cap 0 +1504078123: cap 2: End par conjunct: 0x251b450 +1504080297: cap 2: Trying to steal a spark +1504082367: cap 2: stealing a spark from cap 0 +1510001185: cap 3: End par conjunct: 0x251b4b0 +1510001685: cap 3: Trying to steal a spark +1510002126: cap 3: stealing a spark from cap 0 +1544941570: cap 0: End par conjunct: 0x25279f0 +1544941795: cap 0: End par conjunction: 0x25279f0 +1544941948: cap 0: End par conjunct: 0x2527990 +1544942205: cap 0: running a local spark +1586146329: cap 1: End par conjunct: 0x251b510 +1586148417: cap 1: Trying to steal a spark +1586150667: cap 1: stealing a spark from cap 0 +1595586420: cap 3: End par conjunct: 0x251b5d0 +1595586879: cap 3: Trying to steal a spark +1595587329: cap 3: stealing a spark from cap 0 +1617022876: cap 2: End par conjunct: 0x251b570 +1617024591: cap 2: Trying to steal a spark +1617026719: cap 2: stealing a spark from cap 0 +1672840125: cap 1: End par conjunct: 0x251b630 +1672842082: cap 1: Trying to steal a spark +1672843959: cap 1: stealing a spark from cap 0 +1682179780: cap 3: End par conjunct: 0x251b690 +1682180307: cap 3: Trying to steal a spark +1682180811: cap 3: stealing a spark from cap 0 +1712636509: cap 0: End par conjunct: 0x2527990 +1712636757: cap 0: End par conjunction: 0x2527990 +1712637067: cap 0: End par conjunct: 0x2527930 +1712637333: cap 0: running a local spark +1713749616: cap 2: End par conjunct: 0x251b6f0 +1713751249: cap 2: Trying to steal a spark +1713752950: cap 2: stealing a spark from cap 0 +1760724864: cap 1: End par conjunct: 0x251b750 +1760726002: cap 1: Trying to steal a spark +1760727222: cap 1: stealing a spark from cap 0 +1768582786: cap 3: End par conjunct: 0x251b7b0 +1768583205: cap 3: Trying to steal a spark +1768583812: cap 3: stealing a spark from cap 0 +1797995713: cap 2: End par conjunct: 0x251b810 +1797996865: cap 2: Trying to steal a spark +1797998157: cap 2: stealing a spark from cap 0 +1847496091: cap 1: End par conjunct: 0x251b870 +1847496856: cap 1: Trying to steal a spark +1847497662: cap 1: stealing a spark from cap 0 +1856177788: cap 3: End par conjunct: 0x251b8d0 +1856178396: cap 3: Trying to steal a spark +1856178990: cap 3: stealing a spark from cap 0 +1879742844: cap 0: End par conjunct: 0x2527930 +1879743100: cap 0: End par conjunction: 0x2527930 +1879743289: cap 0: End par conjunct: 0x25278d0 +1879743667: cap 0: running a local spark +1883263333: cap 2: End par conjunct: 0x251b930 +1883264202: cap 2: Trying to steal a spark +1883265142: cap 2: stealing a spark from cap 0 +1937704716: cap 1: End par conjunct: 0x251b990 +1937705656: cap 1: Trying to steal a spark +1937706174: cap 1: stealing a spark from cap 0 +1947000595: cap 3: End par conjunct: 0x251b9f0 +1947001081: cap 3: Trying to steal a spark +1947001675: cap 3: stealing a spark from cap 0 +1972568475: cap 2: End par conjunct: 0x251ba50 +1972569087: cap 2: Trying to steal a spark +1972569622: cap 2: stealing a spark from cap 0 +2030619109: cap 1: End par conjunct: 0x251bab0 +2030619519: cap 1: Trying to steal a spark +2030619991: cap 1: stealing a spark from cap 0 +2040124135: cap 3: End par conjunct: 0x251bb10 +2040124612: cap 3: Trying to steal a spark +2040125067: cap 3: stealing a spark from cap 0 +2062369093: cap 2: End par conjunct: 0x251bb70 +2062369728: cap 2: Trying to steal a spark +2062370209: cap 2: stealing a spark from cap 0 +2078025511: cap 0: End par conjunct: 0x25278d0 +2078025673: cap 0: End par conjunction: 0x25278d0 +2078028985: cap 0: End par conjunct: 0x2527870 +2078029377: cap 0: running a local spark +2124377307: cap 1: End par conjunct: 0x251bbd0 +2124378454: cap 1: Trying to steal a spark +2124379426: cap 1: stealing a spark from cap 0 +2133988411: cap 3: End par conjunct: 0x251bc30 +2133988821: cap 3: Trying to steal a spark +2133989334: cap 3: stealing a spark from cap 0 +2154847783: cap 2: End par conjunct: 0x251bc90 +2154848440: cap 2: Trying to steal a spark +2154848980: cap 2: stealing a spark from cap 0 +2219288427: cap 1: End par conjunct: 0x251bcf0 +2219289138: cap 1: Trying to steal a spark +2219289561: cap 1: stealing a spark from cap 0 +2229366276: cap 3: End par conjunct: 0x251bd50 +2229366739: cap 3: Trying to steal a spark +2229367311: cap 3: stealing a spark from cap 0 +2243419969: cap 0: End par conjunct: 0x2527870 +2243420307: cap 0: End par conjunction: 0x2527870 +2243420500: cap 0: End par conjunct: 0x2527810 +2243420883: cap 0: running a local spark +2247777301: cap 2: End par conjunct: 0x251bdb0 +2247777895: cap 2: Trying to steal a spark +2247778597: cap 2: stealing a spark from cap 0 +2316280018: cap 1: End par conjunct: 0x251be10 +2316280662: cap 1: Trying to steal a spark +2316281274: cap 1: stealing a spark from cap 0 +2325087283: cap 3: End par conjunct: 0x251be70 +2325087769: cap 3: Trying to steal a spark +2325088224: cap 3: stealing a spark from cap 0 +2340641119: cap 2: End par conjunct: 0x251bed0 +2340641866: cap 2: Trying to steal a spark +2340642622: cap 2: stealing a spark from cap 0 +2409047023: cap 0: End par conjunct: 0x2527810 +2409047343: cap 0: End par conjunction: 0x2527810 +2409047532: cap 0: End par conjunct: 0x25277b0 +2409047811: cap 0: running a local spark +2412755536: cap 1: End par conjunct: 0x251bf30 +2412756139: cap 1: Trying to steal a spark +2412756859: cap 1: stealing a spark from cap 0 +2422017855: cap 3: End par conjunct: 0x251bf90 +2422018314: cap 3: Trying to steal a spark +2422018728: cap 3: stealing a spark from cap 0 +2434172382: cap 2: End par conjunct: 0x251bff0 +2434173223: cap 2: Trying to steal a spark +2434173993: cap 2: stealing a spark from cap 0 +2510563581: cap 1: End par conjunct: 0x251c050 +2510565430: cap 1: Trying to steal a spark +2510569161: cap 1: stealing a spark from cap 0 +2520040482: cap 3: End par conjunct: 0x251c0b0 +2520040959: cap 3: Trying to steal a spark +2520041422: cap 3: stealing a spark from cap 0 +2558992500: cap 2: End par conjunct: 0x251c110 +2558994210: cap 2: Trying to steal a spark +2558995884: cap 2: stealing a spark from cap 0 +2574399645: cap 0: End par conjunct: 0x25277b0 +2574399816: cap 0: End par conjunction: 0x25277b0 +2574399969: cap 0: End par conjunct: 0x2527750 +2574400347: cap 0: running a local spark +2610752301: cap 1: End par conjunct: 0x251c170 +2610753934: cap 1: Trying to steal a spark +2610755797: cap 1: stealing a spark from cap 0 +2620085427: cap 3: End par conjunct: 0x251c1d0 +2620086048: cap 3: Trying to steal a spark +2620086768: cap 3: stealing a spark from cap 0 +2675306461: cap 2: End par conjunct: 0x251c230 +2675308347: cap 2: Trying to steal a spark +2675309980: cap 2: stealing a spark from cap 0 +2714796225: cap 1: End par conjunct: 0x251c290 +2714797030: cap 1: Trying to steal a spark +2714797593: cap 1: stealing a spark from cap 0 +2722951039: cap 3: End par conjunct: 0x251c2f0 +2722951467: cap 3: Trying to steal a spark +2722952020: cap 3: stealing a spark from cap 0 +2739383973: cap 0: End par conjunct: 0x2527750 +2739384166: cap 0: End par conjunction: 0x2527750 +2739384342: cap 0: End par conjunct: 0x25276f0 +2739384837: cap 0: running a local spark +2774395746: cap 2: End par conjunct: 0x251c350 +2774396821: cap 2: Trying to steal a spark +2774397874: cap 2: stealing a spark from cap 0 +2823531642: cap 1: End par conjunct: 0x251c3b0 +2823532524: cap 1: Trying to steal a spark +2823533046: cap 1: stealing a spark from cap 0 +2826237402: cap 3: End par conjunct: 0x251c410 +2826237888: cap 3: Trying to steal a spark +2826238351: cap 3: stealing a spark from cap 0 +2875559067: cap 2: End par conjunct: 0x251c470 +2875559715: cap 2: Trying to steal a spark +2875560331: cap 2: stealing a spark from cap 0 +2904336270: cap 0: End par conjunct: 0x25276f0 +2904336459: cap 0: End par conjunction: 0x25276f0 +2904336598: cap 0: End par conjunct: 0x2527690 +2904336945: cap 0: running a local spark +2929743756: cap 1: End par conjunct: 0x251c4d0 +2929744462: cap 1: Trying to steal a spark +2929745119: cap 1: stealing a spark from cap 0 +2932351546: cap 3: End par conjunct: 0x251c530 +2932351933: cap 3: Trying to steal a spark +2932352451: cap 3: stealing a spark from cap 0 +2978596588: cap 2: End par conjunct: 0x251c590 +2978597187: cap 2: Trying to steal a spark +2978598042: cap 2: stealing a spark from cap 0 +3035545497: cap 1: End par conjunct: 0x251c5f0 +3035546145: cap 1: Trying to steal a spark +3035546662: cap 1: stealing a spark from cap 0 +3036216996: cap 3: End par conjunct: 0x251c650 +3036218197: cap 3: Trying to steal a spark +3036218746: cap 3: stealing a spark from cap 0 +3070365034: cap 0: End par conjunct: 0x2527690 +3070365327: cap 0: End par conjunction: 0x2527690 +3070365502: cap 0: End par conjunct: 0x2527630 +3070365894: cap 0: running a local spark +3079323792: cap 2: End par conjunct: 0x251c6b0 +3079324228: cap 2: Trying to steal a spark +3079324786: cap 2: stealing a spark from cap 0 +3139956252: cap 3: End par conjunct: 0x251c770 +3139956657: cap 3: Trying to steal a spark +3139957264: cap 3: stealing a spark from cap 0 +3140464482: cap 1: End par conjunct: 0x251c710 +3140465692: cap 1: Trying to steal a spark +3140466867: cap 1: stealing a spark from cap 0 +3185762184: cap 2: End par conjunct: 0x251c7d0 +3185764056: cap 2: Trying to steal a spark +3185766328: cap 2: stealing a spark from cap 0 +3236157738: cap 0: End par conjunct: 0x2527630 +3236157981: cap 0: End par conjunction: 0x2527630 +3236158165: cap 0: End par conjunct: 0x25275d0 +3236158624: cap 0: running a local spark +3242741305: cap 3: End par conjunct: 0x251c830 +3242741967: cap 3: Trying to steal a spark +3242742264: cap 3: stealing a spark from cap 0 +3244070614: cap 1: End par conjunct: 0x251c890 +3244073584: cap 1: Trying to steal a spark +3244076878: cap 1: stealing a spark from cap 0 +3324819811: cap 2: End par conjunct: 0x251c8f0 +3324821854: cap 2: Trying to steal a spark +3324823920: cap 2: stealing a spark from cap 0 +3346673485: cap 3: End par conjunct: 0x251c950 +3346673917: cap 3: Trying to steal a spark +3346674444: cap 3: stealing a spark from cap 0 +3349538100: cap 1: End par conjunct: 0x251c9b0 +3349539823: cap 1: Trying to steal a spark +3349542892: cap 1: stealing a spark from cap 0 +3401577553: cap 0: End par conjunct: 0x25275d0 +3401577796: cap 0: End par conjunction: 0x25275d0 +3401577976: cap 0: End par conjunct: 0x2527570 +3401578467: cap 0: running a local spark +3438720855: cap 2: End par conjunct: 0x251ca10 +3438722511: cap 2: Trying to steal a spark +3438724752: cap 2: stealing a spark from cap 0 +3450992944: cap 3: End par conjunct: 0x251ca70 +3450993430: cap 3: Trying to steal a spark +3450993997: cap 3: stealing a spark from cap 0 +3455301627: cap 1: End par conjunct: 0x251cad0 +3455302590: cap 1: Trying to steal a spark +3455303166: cap 1: stealing a spark from cap 0 +3540340399: cap 2: End par conjunct: 0x251cb30 +3540340863: cap 2: Trying to steal a spark +3540341277: cap 2: stealing a spark from cap 0 +3555929610: cap 3: End par conjunct: 0x251cb90 +3555930127: cap 3: Trying to steal a spark +3555930694: cap 3: stealing a spark from cap 0 +3560459175: cap 1: End par conjunct: 0x251cbf0 +3560459719: cap 1: Trying to steal a spark +3560460259: cap 1: stealing a spark from cap 0 +3566313765: cap 0: End par conjunct: 0x2527570 +3566314080: cap 0: End par conjunction: 0x2527570 +3566314255: cap 0: End par conjunct: 0x2527510 +3566314651: cap 0: running a local spark +3641768923: cap 2: End par conjunct: 0x251cc50 +3641769747: cap 2: Trying to steal a spark +3641770408: cap 2: stealing a spark from cap 0 +3660900102: cap 3: End par conjunct: 0x251ccb0 +3660900511: cap 3: Trying to steal a spark +3660900966: cap 3: stealing a spark from cap 0 +3665647633: cap 1: End par conjunct: 0x251cd10 +3665648443: cap 1: Trying to steal a spark +3665648970: cap 1: stealing a spark from cap 0 +3730731097: cap 0: End par conjunct: 0x2527510 +3730731304: cap 0: End par conjunction: 0x2527510 +3730731480: cap 0: End par conjunct: 0x25274b0 +3730731885: cap 0: running a local spark +3743352760: cap 2: End par conjunct: 0x251cd70 +3743353305: cap 2: Trying to steal a spark +3743353944: cap 2: stealing a spark from cap 0 +3765799894: cap 3: End par conjunct: 0x251cdd0 +3765800340: cap 3: Trying to steal a spark +3765800794: cap 3: stealing a spark from cap 0 +3771103450: cap 1: End par conjunct: 0x251ce30 +3771103918: cap 1: Trying to steal a spark +3771104539: cap 1: stealing a spark from cap 0 +3850822485: cap 2: End par conjunct: 0x251ce90 +3850824190: cap 2: Trying to steal a spark +3850826094: cap 2: stealing a spark from cap 0 +3871264050: cap 3: End par conjunct: 0x251cef0 +3871264590: cap 3: Trying to steal a spark +3871265094: cap 3: stealing a spark from cap 0 +3878442486: cap 1: End par conjunct: 0x251cf50 +3878443377: cap 1: Trying to steal a spark +3878444070: cap 1: stealing a spark from cap 0 +3895063317: cap 0: End par conjunct: 0x25274b0 +3895063519: cap 0: End par conjunction: 0x25274b0 +3895063668: cap 0: End par conjunct: 0x2527450 +3895064023: cap 0: running a local spark +3977831736: cap 3: End par conjunct: 0x251d010 +3977832244: cap 3: Trying to steal a spark +3977832685: cap 3: stealing a spark from cap 0 +3990236616: cap 2: End par conjunct: 0x251cfb0 +3990238492: cap 2: Trying to steal a spark +3990240571: cap 2: stealing a spark from cap 0 +3991293468: cap 1: End par conjunct: 0x251d070 +3991294359: cap 1: Trying to steal a spark +3991294746: cap 1: stealing a spark from cap 0 +4059510961: cap 0: End par conjunct: 0x2527450 +4059511191: cap 0: End par conjunction: 0x2527450 +4059511479: cap 0: End par conjunct: 0x25273f0 +4059511938: cap 0: running a local spark +4084069900: cap 3: End par conjunct: 0x251d0d0 +4084070413: cap 3: Trying to steal a spark +4084070827: cap 3: stealing a spark from cap 0 +4098127671: cap 1: End par conjunct: 0x251d190 +4098129345: cap 1: Trying to steal a spark +4098131190: cap 1: stealing a spark from cap 0 +4100764009: cap 2: End par conjunct: 0x251d130 +4100764720: cap 2: Trying to steal a spark +4100765107: cap 2: stealing a spark from cap 0 +4189030627: cap 3: End par conjunct: 0x251d1f0 +4189031041: cap 3: Trying to steal a spark +4189031622: cap 3: stealing a spark from cap 0 +4202895316: cap 1: End par conjunct: 0x251d250 +4202896761: cap 1: Trying to steal a spark +4202897868: cap 1: stealing a spark from cap 0 +4203368370: cap 2: End par conjunct: 0x251d2b0 +4203369009: cap 2: Trying to steal a spark +4203369432: cap 2: stealing a spark from cap 0 +4224118374: cap 0: End par conjunct: 0x25273f0 +4224118594: cap 0: End par conjunction: 0x25273f0 +4224118779: cap 0: End par conjunct: 0x2527390 +4224119193: cap 0: running a local spark +4293500643: cap 3: End par conjunct: 0x251d310 +4293501210: cap 3: Trying to steal a spark +4293501547: cap 3: stealing a spark from cap 0 +4303451088: cap 2: End par conjunct: 0x251d3d0 +4303451740: cap 2: Trying to steal a spark +4303452370: cap 2: stealing a spark from cap 0 +4306702729: cap 1: End par conjunct: 0x251d370 +4306703229: cap 1: Trying to steal a spark +4306703593: cap 1: stealing a spark from cap 0 +4388432976: cap 0: End par conjunct: 0x2527390 +4388433246: cap 0: End par conjunction: 0x2527390 +4388433552: cap 0: End par conjunct: 0x2527330 +4388433889: cap 0: running a local spark +4396328653: cap 3: End par conjunct: 0x251d430 +4396329103: cap 3: Trying to steal a spark +4396329517: cap 3: stealing a spark from cap 0 +4403295733: cap 2: End par conjunct: 0x251d490 +4403296300: cap 2: Trying to steal a spark +4403297182: cap 2: stealing a spark from cap 0 +4410306522: cap 1: End par conjunct: 0x251d4f0 +4410306877: cap 1: Trying to steal a spark +4410307246: cap 1: stealing a spark from cap 0 +4499511997: cap 3: End par conjunct: 0x251d550 +4499512465: cap 3: Trying to steal a spark +4499512956: cap 3: stealing a spark from cap 0 +4502380810: cap 2: End par conjunct: 0x251d5b0 +4502381359: cap 2: Trying to steal a spark +4502381818: cap 2: stealing a spark from cap 0 +4512594357: cap 1: End par conjunct: 0x251d610 +4512594910: cap 1: Trying to steal a spark +4512595275: cap 1: stealing a spark from cap 0 +4552369659: cap 0: End par conjunct: 0x2527330 +4552369816: cap 0: End par conjunction: 0x2527330 +4552369951: cap 0: End par conjunct: 0x25272d0 +4552370226: cap 0: running a local spark +4600086066: cap 3: End par conjunct: 0x251d670 +4600086556: cap 3: Trying to steal a spark +4600086817: cap 3: stealing a spark from cap 0 +4604659614: cap 2: End par conjunct: 0x251d6d0 +4604661180: cap 2: Trying to steal a spark +4604662786: cap 2: stealing a spark from cap 0 +4612849681: cap 1: End par conjunct: 0x251d730 +4612850379: cap 1: Trying to steal a spark +4612850883: cap 1: stealing a spark from cap 0 +4699006281: cap 3: End par conjunct: 0x251d790 +4699006843: cap 3: Trying to steal a spark +4699007370: cap 3: stealing a spark from cap 0 +4710339432: cap 1: End par conjunct: 0x251d850 +4710341389: cap 1: Trying to steal a spark +4710343032: cap 1: stealing a spark from cap 0 +4716631368: cap 0: End par conjunct: 0x25272d0 +4716631579: cap 0: End par conjunction: 0x25272d0 +4716631741: cap 0: End par conjunct: 0x2527270 +4716632142: cap 0: running a local spark +4735995192: cap 2: End par conjunct: 0x251d7f0 +4735995916: cap 2: Trying to steal a spark +4735996753: cap 2: stealing a spark from cap 0 +4802625774: cap 1: End par conjunct: 0x251d910 +4802627380: cap 1: Trying to steal a spark +4802629302: cap 1: stealing a spark from cap 0 +4805334769: cap 3: End par conjunct: 0x251d8b0 +4805336542: cap 3: Trying to steal a spark +4805338437: cap 3: stealing a spark from cap 0 +4831134097: cap 2: End par conjunct: 0x251d970 +4831134948: cap 2: Trying to steal a spark +4831135785: cap 2: stealing a spark from cap 0 +4880466819: cap 0: End par conjunct: 0x2527270 +4880467201: cap 0: End par conjunction: 0x2527270 +4880467507: cap 0: End par conjunct: 0x2527210 +4880467917: cap 0: running a local spark +4894799611: cap 1: End par conjunct: 0x251d9d0 +4894800457: cap 1: Trying to steal a spark +4894801132: cap 1: stealing a spark from cap 0 +4896399325: cap 3: End par conjunct: 0x251da30 +4896399721: cap 3: Trying to steal a spark +4896400383: cap 3: stealing a spark from cap 0 +4919787211: cap 2: End par conjunct: 0x251da90 +4919787738: cap 2: Trying to steal a spark +4919788192: cap 2: stealing a spark from cap 0 +4987284781: cap 1: End par conjunct: 0x251daf0 +4987285263: cap 1: Trying to steal a spark +4987285713: cap 1: stealing a spark from cap 0 +4988328228: cap 3: End par conjunct: 0x251db50 +4988328700: cap 3: Trying to steal a spark +4988329227: cap 3: stealing a spark from cap 0 +5009116779: cap 2: End par conjunct: 0x251dbb0 +5009117323: cap 2: Trying to steal a spark +5009117805: cap 2: stealing a spark from cap 0 +5044457664: cap 0: End par conjunct: 0x2527210 +5044458010: cap 0: End par conjunction: 0x2527210 +5044458235: cap 0: End par conjunct: 0x25271b0 +5044458622: cap 0: running a local spark +5080150813: cap 1: End par conjunct: 0x251dc10 +5080151259: cap 1: Trying to steal a spark +5080151767: cap 1: stealing a spark from cap 0 +5081340006: cap 3: End par conjunct: 0x251dc70 +5081340672: cap 3: Trying to steal a spark +5081341099: cap 3: stealing a spark from cap 0 +5099104935: cap 2: End par conjunct: 0x251dcd0 +5099105610: cap 2: Trying to steal a spark +5099106096: cap 2: stealing a spark from cap 0 +5174841456: cap 3: End par conjunct: 0x251dd90 +5174841910: cap 3: Trying to steal a spark +5174842351: cap 3: stealing a spark from cap 0 +5179632331: cap 1: End par conjunct: 0x251dd30 +5179633258: cap 1: Trying to steal a spark +5179634032: cap 1: stealing a spark from cap 0 +5190281595: cap 2: End par conjunct: 0x251ddf0 +5190282031: cap 2: Trying to steal a spark +5190282355: cap 2: stealing a spark from cap 0 +5208519726: cap 0: End par conjunct: 0x25271b0 +5208519951: cap 0: End par conjunction: 0x25271b0 +5208520212: cap 0: End par conjunct: 0x2527150 +5208520594: cap 0: running a local spark +5269359082: cap 3: End par conjunct: 0x251de50 +5269359537: cap 3: Trying to steal a spark +5269359901: cap 3: stealing a spark from cap 0 +5274835857: cap 1: End par conjunct: 0x251deb0 +5274836505: cap 1: Trying to steal a spark +5274837094: cap 1: stealing a spark from cap 0 +5282239549: cap 2: End par conjunct: 0x251df10 +5282239977: cap 2: Trying to steal a spark +5282240287: cap 2: stealing a spark from cap 0 +5364891751: cap 3: End par conjunct: 0x251df70 +5364892188: cap 3: Trying to steal a spark +5364892642: cap 3: stealing a spark from cap 0 +5371093939: cap 1: End par conjunct: 0x251dfd0 +5371094565: cap 1: Trying to steal a spark +5371095226: cap 1: stealing a spark from cap 0 +5372349538: cap 0: End par conjunct: 0x2527150 +5372349732: cap 0: End par conjunction: 0x2527150 +5372349907: cap 0: End par conjunct: 0x25270f0 +5372350204: cap 0: running a local spark +5375287273: cap 2: End par conjunct: 0x251e030 +5375287737: cap 2: Trying to steal a spark +5375288263: cap 2: stealing a spark from cap 0 +5460822751: cap 3: End par conjunct: 0x251e090 +5460823359: cap 3: Trying to steal a spark +5460824029: cap 3: stealing a spark from cap 0 +5468675634: cap 1: End par conjunct: 0x251e0f0 +5468677600: cap 1: Trying to steal a spark +5468679922: cap 1: stealing a spark from cap 0 +5511468537: cap 2: End par conjunct: 0x251e150 +5511470931: cap 2: Trying to steal a spark +5511472380: cap 2: stealing a spark from cap 0 +5536802232: cap 0: End par conjunct: 0x25270f0 +5536802448: cap 0: End par conjunction: 0x25270f0 +5536802619: cap 0: End par conjunct: 0x2527090 +5536802916: cap 0: running a local spark +5558417905: cap 3: End par conjunct: 0x251e1b0 +5558418310: cap 3: Trying to steal a spark +5558418571: cap 3: stealing a spark from cap 0 +5566822195: cap 1: End par conjunct: 0x251e210 +5566823829: cap 1: Trying to steal a spark +5566825089: cap 1: stealing a spark from cap 0 +5613784794: cap 2: End par conjunct: 0x251e270 +5613786652: cap 2: Trying to steal a spark +5613788389: cap 2: stealing a spark from cap 0 +5656165357: cap 3: End par conjunct: 0x251e2d0 +5656165731: cap 3: Trying to steal a spark +5656166226: cap 3: stealing a spark from cap 0 +5667148989: cap 1: End par conjunct: 0x251e330 +5667150114: cap 1: Trying to steal a spark +5667151266: cap 1: stealing a spark from cap 0 +5702150182: cap 0: End par conjunct: 0x2527090 +5702150398: cap 0: End par conjunction: 0x2527090 +5702150677: cap 0: End par conjunct: 0x2527030 +5702151082: cap 0: running a local spark +5710287978: cap 2: End par conjunct: 0x251e390 +5710288504: cap 2: Trying to steal a spark +5710289094: cap 2: stealing a spark from cap 0 +5755608112: cap 3: End par conjunct: 0x251e3f0 +5755608495: cap 3: Trying to steal a spark +5755608940: cap 3: stealing a spark from cap 0 +5767399530: cap 1: End par conjunct: 0x251e450 +5767400074: cap 1: Trying to steal a spark +5767400655: cap 1: stealing a spark from cap 0 +5806750243: cap 2: End par conjunct: 0x251e4b0 +5806750702: cap 2: Trying to steal a spark +5806751017: cap 2: stealing a spark from cap 0 +5854923580: cap 3: End par conjunct: 0x251e510 +5854924039: cap 3: Trying to steal a spark +5854924462: cap 3: stealing a spark from cap 0 +5867308777: cap 1: End par conjunct: 0x251e570 +5867309322: cap 1: Trying to steal a spark +5867309866: cap 1: stealing a spark from cap 0 +5868694615: cap 0: End par conjunct: 0x2527030 +5868694818: cap 0: End par conjunction: 0x2527030 +5868694980: cap 0: End par conjunct: 0x2526fd0 +5868695389: cap 0: running a local spark +5903779621: cap 2: End par conjunct: 0x251e5d0 +5903780049: cap 2: Trying to steal a spark +5903780517: cap 2: stealing a spark from cap 0 +5955976417: cap 3: End par conjunct: 0x251e630 +5955976791: cap 3: Trying to steal a spark +5955977236: cap 3: stealing a spark from cap 0 +5969468290: cap 1: End par conjunct: 0x251e690 +5969468898: cap 1: Trying to steal a spark +5969469487: cap 1: stealing a spark from cap 0 +6002940645: cap 2: End par conjunct: 0x251e6f0 +6002940960: cap 2: Trying to steal a spark +6002941293: cap 2: stealing a spark from cap 0 +6036253218: cap 0: End par conjunct: 0x2526fd0 +6036253488: cap 0: End par conjunction: 0x2526fd0 +6036253771: cap 0: End par conjunct: 0x2526f70 +6036254190: cap 0: running a local spark +6058467171: cap 3: End par conjunct: 0x251e750 +6058467612: cap 3: Trying to steal a spark +6058467877: cap 3: stealing a spark from cap 0 +6073172662: cap 1: End par conjunct: 0x251e7b0 +6073173180: cap 1: Trying to steal a spark +6073173729: cap 1: stealing a spark from cap 0 +6102897106: cap 2: End par conjunct: 0x251e810 +6102897525: cap 2: Trying to steal a spark +6102897934: cap 2: stealing a spark from cap 0 +6161465551: cap 3: End par conjunct: 0x251e870 +6161465925: cap 3: Trying to steal a spark +6161466361: cap 3: stealing a spark from cap 0 +6176467750: cap 1: End par conjunct: 0x251e8d0 +6176468272: cap 1: Trying to steal a spark +6176468862: cap 1: stealing a spark from cap 0 +6202076346: cap 2: End par conjunct: 0x251e930 +6202076782: cap 2: Trying to steal a spark +6202077183: cap 2: stealing a spark from cap 0 +6202608786: cap 0: End par conjunct: 0x2526f70 +6202608993: cap 0: End par conjunction: 0x2526f70 +6202609159: cap 0: End par conjunct: 0x2526f10 +6202609461: cap 0: running a local spark +6264545985: cap 3: End par conjunct: 0x251e990 +6264546435: cap 3: Trying to steal a spark +6264546718: cap 3: stealing a spark from cap 0 +6280029117: cap 1: End par conjunct: 0x251e9f0 +6280030134: cap 1: Trying to steal a spark +6280031272: cap 1: stealing a spark from cap 0 +6302836035: cap 2: End par conjunct: 0x251ea50 +6302836521: cap 2: Trying to steal a spark +6302837034: cap 2: stealing a spark from cap 0 +6364841238: cap 0: End par conjunct: 0x2526f10 +6364841436: cap 0: End par conjunction: 0x2526f10 +6364841580: cap 0: End par conjunct: 0x2526eb0 +6364841931: cap 0: running a local spark +6368895904: cap 3: End par conjunct: 0x251eab0 +6368896278: cap 3: Trying to steal a spark +6368896660: cap 3: stealing a spark from cap 0 +6391330479: cap 1: End par conjunct: 0x251eb10 +6391331721: cap 1: Trying to steal a spark +6391332729: cap 1: stealing a spark from cap 0 +6406162888: cap 2: End par conjunct: 0x251eb70 +6406163248: cap 2: Trying to steal a spark +6406163586: cap 2: stealing a spark from cap 0 +6475439569: cap 3: End par conjunct: 0x251ebd0 +6475440010: cap 3: Trying to steal a spark +6475440442: cap 3: stealing a spark from cap 0 +6498971127: cap 1: End par conjunct: 0x251ec30 +6498971671: cap 1: Trying to steal a spark +6498972477: cap 1: stealing a spark from cap 0 +6510126928: cap 2: End par conjunct: 0x251ec90 +6510127342: cap 2: Trying to steal a spark +6510127675: cap 2: stealing a spark from cap 0 +6532580326: cap 0: End par conjunct: 0x2526eb0 +6532580713: cap 0: End par conjunction: 0x2526eb0 +6532580866: cap 0: End par conjunct: 0x2526e50 +6532581163: cap 0: running a local spark +6583930695: cap 3: End par conjunct: 0x251ecf0 +6583931239: cap 3: Trying to steal a spark +6583931568: cap 3: stealing a spark from cap 0 +6607367370: cap 1: End par conjunct: 0x251ed50 +6607367905: cap 1: Trying to steal a spark +6607368616: cap 1: stealing a spark from cap 0 +6615017739: cap 2: End par conjunct: 0x251edb0 +6615018261: cap 2: Trying to steal a spark +6615018598: cap 2: stealing a spark from cap 0 +6692534527: cap 3: End par conjunct: 0x251ee10 +6692535103: cap 3: Trying to steal a spark +6692535679: cap 3: stealing a spark from cap 0 +6700865737: cap 0: End par conjunct: 0x2526e50 +6700865953: cap 0: End par conjunction: 0x2526e50 +6700866138: cap 0: End par conjunct: 0x2526df0 +6700866475: cap 0: running a local spark +6716408625: cap 1: End par conjunct: 0x251ee70 +6716409237: cap 1: Trying to steal a spark +6716410335: cap 1: stealing a spark from cap 0 +6720467719: cap 2: End par conjunct: 0x251eed0 +6720468286: cap 2: Trying to steal a spark +6720468646: cap 2: stealing a spark from cap 0 +6806783403: cap 3: End par conjunct: 0x251ef30 +6806785135: cap 3: Trying to steal a spark +6806786967: cap 3: stealing a spark from cap 0 +6823963629: cap 2: End par conjunct: 0x251eff0 +6823964236: cap 2: Trying to steal a spark +6823964790: cap 2: stealing a spark from cap 0 +6825203406: cap 1: End par conjunct: 0x251ef90 +6825203973: cap 1: Trying to steal a spark +6825204369: cap 1: stealing a spark from cap 0 +6869104015: cap 0: End par conjunct: 0x2526df0 +6869104672: cap 0: End par conjunction: 0x2526df0 +6869105190: cap 0: End par conjunct: 0x2526d90 +6869106378: cap 0: running a local spark +6928249585: cap 2: End par conjunct: 0x251f0b0 +6928249995: cap 2: Trying to steal a spark +6928250413: cap 2: stealing a spark from cap 0 +6933589821: cap 1: End par conjunct: 0x251f110 +6933590262: cap 1: Trying to steal a spark +6933590635: cap 1: stealing a spark from cap 0 +6956958510: cap 3: End par conjunct: 0x251f050 +6956960251: cap 3: Trying to steal a spark +6956962425: cap 3: stealing a spark from cap 0 +7033972122: cap 2: End par conjunct: 0x251f170 +7033973503: cap 2: Trying to steal a spark +7033974840: cap 2: stealing a spark from cap 0 +7037497476: cap 0: End par conjunct: 0x2526d90 +7037497863: cap 0: End par conjunction: 0x2526d90 +7037498353: cap 0: End par conjunct: 0x2526d30 +7037498799: cap 0: running a local spark +7043018242: cap 1: End par conjunct: 0x251f1d0 +7043018877: cap 1: Trying to steal a spark +7043019408: cap 1: stealing a spark from cap 0 +7065907465: cap 3: End par conjunct: 0x251f230 +7065907906: cap 3: Trying to steal a spark +7065908442: cap 3: stealing a spark from cap 0 +7139790391: cap 2: End par conjunct: 0x251f290 +7139791053: cap 2: Trying to steal a spark +7139791656: cap 2: stealing a spark from cap 0 +7154419621: cap 1: End par conjunct: 0x251f2f0 +7154420130: cap 1: Trying to steal a spark +7154420463: cap 1: stealing a spark from cap 0 +7178493060: cap 3: End par conjunct: 0x251f350 +7178493568: cap 3: Trying to steal a spark +7178494023: cap 3: stealing a spark from cap 0 +7205940342: cap 0: End par conjunct: 0x2526d30 +7205940661: cap 0: End par conjunction: 0x2526d30 +7205940810: cap 0: End par conjunct: 0x2526cd0 +7205941197: cap 0: running a local spark +7249679901: cap 2: End par conjunct: 0x251f3b0 +7249680679: cap 2: Trying to steal a spark +7249681525: cap 2: stealing a spark from cap 0 +7270700197: cap 1: End par conjunct: 0x251f410 +7270700742: cap 1: Trying to steal a spark +7270701111: cap 1: stealing a spark from cap 0 +7294506664: cap 3: End par conjunct: 0x251f470 +7294507105: cap 3: Trying to steal a spark +7294507659: cap 3: stealing a spark from cap 0 +7362194377: cap 2: End par conjunct: 0x251f4d0 +7362195111: cap 2: Trying to steal a spark +7362195624: cap 2: stealing a spark from cap 0 +7374448426: cap 0: End par conjunct: 0x2526cd0 +7374448746: cap 0: End par conjunction: 0x2526cd0 +7374448917: cap 0: End par conjunct: 0x2526c70 +7374449488: cap 0: running a local spark +7388212914: cap 1: End par conjunct: 0x251f530 +7388214682: cap 1: Trying to steal a spark +7388216793: cap 1: stealing a spark from cap 0 +7409992662: cap 3: End par conjunct: 0x251f590 +7409993112: cap 3: Trying to steal a spark +7409993548: cap 3: stealing a spark from cap 0 +7505717877: cap 1: End par conjunct: 0x251f650 +7505719911: cap 1: Trying to steal a spark +7505722413: cap 1: stealing a spark from cap 0 +7516908211: cap 2: End par conjunct: 0x251f5f0 +7516909035: cap 2: Trying to steal a spark +7516909422: cap 2: stealing a spark from cap 0 +7526619144: cap 3: End par conjunct: 0x251f6b0 +7526619607: cap 3: Trying to steal a spark +7526620030: cap 3: stealing a spark from cap 0 +7542900904: cap 0: End par conjunct: 0x2526c70 +7542901093: cap 0: End par conjunction: 0x2526c70 +7542901233: cap 0: End par conjunct: 0x2526c10 +7542901593: cap 0: running a local spark +7629785779: cap 1: End par conjunct: 0x251f710 +7629787647: cap 1: Trying to steal a spark +7629789586: cap 1: stealing a spark from cap 0 +7638019537: cap 2: End par conjunct: 0x251f770 +7638020248: cap 2: Trying to steal a spark +7638020640: cap 2: stealing a spark from cap 0 +7644842095: cap 3: End par conjunct: 0x251f7d0 +7644842563: cap 3: Trying to steal a spark +7644843103: cap 3: stealing a spark from cap 0 +7711580452: cap 0: End par conjunct: 0x2526c10 +7711580659: cap 0: End par conjunction: 0x2526c10 +7711580830: cap 0: End par conjunct: 0x2526bb0 +7711581078: cap 0: running a local spark +7748250741: cap 1: End par conjunct: 0x251f830 +7748251834: cap 1: Trying to steal a spark +7748253274: cap 1: stealing a spark from cap 0 +7752907786: cap 2: End par conjunct: 0x251f890 +7752908403: cap 2: Trying to steal a spark +7752908754: cap 2: stealing a spark from cap 0 +7762712247: cap 3: End par conjunct: 0x251f8f0 +7762712625: cap 3: Trying to steal a spark +7762713061: cap 3: stealing a spark from cap 0 +7866824067: cap 1: End par conjunct: 0x251f950 +7866824791: cap 1: Trying to steal a spark +7866825435: cap 1: stealing a spark from cap 0 +7868129994: cap 2: End par conjunct: 0x251f9b0 +7868130318: cap 2: Trying to steal a spark +7868130660: cap 2: stealing a spark from cap 0 +7880553090: cap 0: End par conjunct: 0x2526bb0 +7880553283: cap 0: End par conjunction: 0x2526bb0 +7880553571: cap 0: End par conjunct: 0x2526b50 +7880553886: cap 0: running a local spark +7881310125: cap 3: End par conjunct: 0x251fa10 +7881310575: cap 3: Trying to steal a spark +7881310930: cap 3: stealing a spark from cap 0 +7983051835: cap 2: End par conjunct: 0x251fad0 +7983052690: cap 2: Trying to steal a spark +7983053311: cap 2: stealing a spark from cap 0 +7986387316: cap 1: End par conjunct: 0x251fa70 +7986387856: cap 1: Trying to steal a spark +7986388225: cap 1: stealing a spark from cap 0 +7999363462: cap 3: End par conjunct: 0x251fb30 +7999363831: cap 3: Trying to steal a spark +7999364371: cap 3: stealing a spark from cap 0 +8049000447: cap 0: End par conjunct: 0x2526b50 +8049000636: cap 0: End par conjunction: 0x2526b50 +8049000807: cap 0: End par conjunct: 0x2526af0 +8049001171: cap 0: running a local spark +8097602877: cap 2: End par conjunct: 0x251fb90 +8097603786: cap 2: Trying to steal a spark +8097604686: cap 2: stealing a spark from cap 0 +8105726808: cap 1: End par conjunct: 0x251fbf0 +8105727348: cap 1: Trying to steal a spark +8105727708: cap 1: stealing a spark from cap 0 +8122236853: cap 3: End par conjunct: 0x251fc50 +8122238694: cap 3: Trying to steal a spark +8122240728: cap 3: stealing a spark from cap 0 +8209894459: cap 2: End par conjunct: 0x251fcb0 +8209895179: cap 2: Trying to steal a spark +8209895760: cap 2: stealing a spark from cap 0 +8217917545: cap 0: End par conjunct: 0x2526af0 +8217918414: cap 0: End par conjunction: 0x2526af0 +8217918882: cap 0: End par conjunct: 0x2526a90 +8217919912: cap 0: running a local spark +8222221260: cap 1: End par conjunct: 0x251fd10 +8222221822: cap 1: Trying to steal a spark +8222222331: cap 1: stealing a spark from cap 0 +8274741862: cap 3: End par conjunct: 0x251fd70 +8274743266: cap 3: Trying to steal a spark +8274745170: cap 3: stealing a spark from cap 0 +8322421567: cap 2: End par conjunct: 0x251fdd0 +8322422215: cap 2: Trying to steal a spark +8322422940: cap 2: stealing a spark from cap 0 +8338848345: cap 1: End par conjunct: 0x251fe30 +8338848705: cap 1: Trying to steal a spark +8338849056: cap 1: stealing a spark from cap 0 +8387412912: cap 0: End par conjunct: 0x2526a90 +8387413497: cap 0: End par conjunction: 0x2526a90 +8387414005: cap 0: End par conjunct: 0x2526a30 +8387415427: cap 0: running a local spark +8397977359: cap 3: End par conjunct: 0x251fe90 +8397978768: cap 3: Trying to steal a spark +8397980046: cap 3: stealing a spark from cap 0 +8435992648: cap 2: End par conjunct: 0x251fef0 +8435993760: cap 2: Trying to steal a spark +8435994781: cap 2: stealing a spark from cap 0 +8456515038: cap 1: End par conjunct: 0x251ff50 +8456515564: cap 1: Trying to steal a spark +8456515929: cap 1: stealing a spark from cap 0 +8514977890: cap 3: End par conjunct: 0x251ffb0 +8514978282: cap 3: Trying to steal a spark +8514978934: cap 3: stealing a spark from cap 0 +8550261373: cap 2: End par conjunct: 0x2520010 +8550261990: cap 2: Trying to steal a spark +8550262786: cap 2: stealing a spark from cap 0 +8556870406: cap 0: End par conjunct: 0x2526a30 +8556870582: cap 0: End par conjunction: 0x2526a30 +8556870753: cap 0: End par conjunct: 0x25269d0 +8556871288: cap 0: running a local spark +8574920581: cap 1: End par conjunct: 0x2520070 +8574921054: cap 1: Trying to steal a spark +8574921639: cap 1: stealing a spark from cap 0 +8633149510: cap 3: End par conjunct: 0x25200d0 +8633150113: cap 3: Trying to steal a spark +8633150716: cap 3: stealing a spark from cap 0 +8664787926: cap 2: End par conjunct: 0x2520130 +8664788367: cap 2: Trying to steal a spark +8664789078: cap 2: stealing a spark from cap 0 +8694223839: cap 1: End par conjunct: 0x2520190 +8694224397: cap 1: Trying to steal a spark +8694224788: cap 1: stealing a spark from cap 0 +8726062792: cap 0: End par conjunct: 0x25269d0 +8726062995: cap 0: End par conjunction: 0x25269d0 +8726063166: cap 0: End par conjunct: 0x2526970 +8726063571: cap 0: running a local spark +8752188550: cap 3: End par conjunct: 0x25201f0 +8752189995: cap 3: Trying to steal a spark +8752191502: cap 3: stealing a spark from cap 0 +8780949805: cap 2: End par conjunct: 0x2520250 +8780951065: cap 2: Trying to steal a spark +8780952100: cap 2: stealing a spark from cap 0 +8819446338: cap 1: End par conjunct: 0x25202b0 +8819447175: cap 1: Trying to steal a spark +8819447544: cap 1: stealing a spark from cap 0 +8871555856: cap 3: End par conjunct: 0x2520310 +8871557584: cap 3: Trying to steal a spark +8871559020: cap 3: stealing a spark from cap 0 +8896779094: cap 2: End par conjunct: 0x2520370 +8896779801: cap 2: Trying to steal a spark +8896780467: cap 2: stealing a spark from cap 0 +8937728199: cap 0: End par conjunct: 0x2526970 +8937728946: cap 0: End par conjunction: 0x2526970 +8937729603: cap 0: End par conjunct: 0x2526910 +8937730624: cap 0: running a local spark +8941134757: cap 1: End par conjunct: 0x25203d0 +8941135234: cap 1: Trying to steal a spark +8941135860: cap 1: stealing a spark from cap 0 +8994217396: cap 3: End par conjunct: 0x2520430 +8994218571: cap 3: Trying to steal a spark +8994220483: cap 3: stealing a spark from cap 0 +9016329973: cap 2: End par conjunct: 0x2520490 +9016330657: cap 2: Trying to steal a spark +9016331319: cap 2: stealing a spark from cap 0 +9065391511: cap 1: End par conjunct: 0x25204f0 +9065392182: cap 1: Trying to steal a spark +9065392542: cap 1: stealing a spark from cap 0 +9114060033: cap 0: End par conjunct: 0x2526910 +9114061369: cap 0: End par conjunction: 0x2526910 +9114062017: cap 0: End par conjunct: 0x25268b0 +9114063439: cap 0: running a local spark +9118985994: cap 3: End par conjunct: 0x2520550 +9118987276: cap 3: Trying to steal a spark +9118988649: cap 3: stealing a spark from cap 0 +9137965891: cap 2: End par conjunct: 0x25205b0 +9137966944: cap 2: Trying to steal a spark +9137967768: cap 2: stealing a spark from cap 0 +9190963782: cap 1: End par conjunct: 0x2520610 +9190964430: cap 1: Trying to steal a spark +9190964794: cap 1: stealing a spark from cap 0 +9244042654: cap 3: End par conjunct: 0x2520670 +9244043077: cap 3: Trying to steal a spark +9244043527: cap 3: stealing a spark from cap 0 +9259115341: cap 2: End par conjunct: 0x25206d0 +9259115881: cap 2: Trying to steal a spark +9259116448: cap 2: stealing a spark from cap 0 +9316672281: cap 1: End par conjunct: 0x2520730 +9316672717: cap 1: Trying to steal a spark +9316673172: cap 1: stealing a spark from cap 0 +9318656340: cap 0: End par conjunct: 0x25268b0 +9318656502: cap 0: End par conjunction: 0x25268b0 +9318656637: cap 0: End par conjunct: 0x2526850 +9318656965: cap 0: running a local spark +9369180099: cap 3: End par conjunct: 0x2520790 +9369180544: cap 3: Trying to steal a spark +9369180931: cap 3: stealing a spark from cap 0 +9383760999: cap 2: End par conjunct: 0x25207f0 +9383761741: cap 2: Trying to steal a spark +9383762263: cap 2: stealing a spark from cap 0 +9449296929: cap 1: End par conjunct: 0x2520850 +9449297469: cap 1: Trying to steal a spark +9449297946: cap 1: stealing a spark from cap 0 +9485841762: cap 0: End par conjunct: 0x2526850 +9485841924: cap 0: End par conjunction: 0x2526850 +9485842077: cap 0: End par conjunct: 0x25267f0 +9485842509: cap 0: running a local spark +9502258122: cap 3: End par conjunct: 0x25208b0 +9502258671: cap 3: Trying to steal a spark +9502258995: cap 3: stealing a spark from cap 0 +9514881801: cap 2: End par conjunct: 0x2520910 +9514882534: cap 2: Trying to steal a spark +9514883137: cap 2: stealing a spark from cap 0 +9586031359: cap 1: End par conjunct: 0x2520970 +9586031724: cap 1: Trying to steal a spark +9586032093: cap 1: stealing a spark from cap 0 +9638764969: cap 3: End par conjunct: 0x25209d0 +9638765464: cap 3: Trying to steal a spark +9638765941: cap 3: stealing a spark from cap 0 +9651997687: cap 0: End par conjunct: 0x25267f0 +9651998029: cap 0: End par conjunction: 0x25267f0 +9651998214: cap 0: End par conjunct: 0x2526790 +9651998565: cap 0: running a local spark +9654841575: cap 2: End par conjunct: 0x2520a30 +9654843897: cap 2: Trying to steal a spark +9654845958: cap 2: stealing a spark from cap 0 +9725912271: cap 1: End par conjunct: 0x2520a90 +9725915304: cap 1: Trying to steal a spark +9725918872: cap 1: stealing a spark from cap 0 +9777878748: cap 3: End par conjunct: 0x2520af0 +9777879166: cap 3: Trying to steal a spark +9777879670: cap 3: stealing a spark from cap 0 +9824287432: cap 0: End par conjunct: 0x2526790 +9824288269: cap 0: End par conjunction: 0x2526790 +9824288706: cap 0: End par conjunct: 0x2526730 +9824289768: cap 0: running a local spark +9830543400: cap 2: End par conjunct: 0x2520b50 +9830545330: cap 2: Trying to steal a spark +9830547454: cap 2: stealing a spark from cap 0 +9867722602: cap 1: End par conjunct: 0x2520bb0 +9867723367: cap 1: Trying to steal a spark +9867723768: cap 1: stealing a spark from cap 0 +9918449059: cap 3: End par conjunct: 0x2520c10 +9918450211: cap 3: Trying to steal a spark +9918451539: cap 3: stealing a spark from cap 0 +9967959841: cap 2: End par conjunct: 0x2520c70 +9967961182: cap 2: Trying to steal a spark +9967962555: cap 2: stealing a spark from cap 0 +9989056377: cap 0: End par conjunct: 0x2526730 +9989056579: cap 0: End par conjunction: 0x2526730 +9989056858: cap 0: End par conjunct: 0x25266d0 +9989057290: cap 0: running a local spark +10015182895: cap 1: End par conjunct: 0x2520cd0 +10015183467: cap 1: Trying to steal a spark +10015184277: cap 1: stealing a spark from cap 0 +10059675948: cap 3: End par conjunct: 0x2520d30 +10059676402: cap 3: Trying to steal a spark +10059676888: cap 3: stealing a spark from cap 0 +10105111224: cap 2: End par conjunct: 0x2520d90 +10105111881: cap 2: Trying to steal a spark +10105112583: cap 2: stealing a spark from cap 0 +10153755009: cap 0: End par conjunct: 0x25266d0 +10153755400: cap 0: End par conjunction: 0x25266d0 +10153755567: cap 0: End par conjunct: 0x2526670 +10153756350: cap 0: running a local spark +10156564170: cap 1: End par conjunct: 0x2520df0 +10156564795: cap 1: Trying to steal a spark +10156565889: cap 1: stealing a spark from cap 0 +10199449233: cap 3: End par conjunct: 0x2520e50 +10199449971: cap 3: Trying to steal a spark +10199450623: cap 3: stealing a spark from cap 0 +10242140503: cap 2: End par conjunct: 0x2520eb0 +10242141174: cap 2: Trying to steal a spark +10242141844: cap 2: stealing a spark from cap 0 +10297449207: cap 1: End par conjunct: 0x2520f10 +10297449886: cap 1: Trying to steal a spark +10297450435: cap 1: stealing a spark from cap 0 +10317707554: cap 0: End par conjunct: 0x2526670 +10317707797: cap 0: End par conjunction: 0x2526670 +10317707968: cap 0: End par conjunct: 0x2526610 +10317708265: cap 0: running a local spark +10340165916: cap 3: End par conjunct: 0x2520f70 +10340166298: cap 3: Trying to steal a spark +10340166829: cap 3: stealing a spark from cap 0 +10378737562: cap 2: End par conjunct: 0x2520fd0 +10378738183: cap 2: Trying to steal a spark +10378738926: cap 2: stealing a spark from cap 0 +10438743933: cap 1: End par conjunct: 0x2521030 +10438745697: cap 1: Trying to steal a spark +10438747713: cap 1: stealing a spark from cap 0 +10480589802: cap 0: End par conjunct: 0x2526610 +10480590054: cap 0: End par conjunction: 0x2526610 +10480590229: cap 0: End par conjunct: 0x25265b0 +10480590585: cap 0: running a local spark +10481222119: cap 3: End par conjunct: 0x2521090 +10481222790: cap 3: Trying to steal a spark +10481223469: cap 3: stealing a spark from cap 0 +10563616602: cap 2: End par conjunct: 0x25210f0 +10563618640: cap 2: Trying to steal a spark +10563620764: cap 2: stealing a spark from cap 0 +10583217459: cap 1: End par conjunct: 0x2521150 +10583219313: cap 1: Trying to steal a spark +10583221414: cap 1: stealing a spark from cap 0 +10623586666: cap 3: End par conjunct: 0x25211b0 +10623587157: cap 3: Trying to steal a spark +10623587679: cap 3: stealing a spark from cap 0 +10642220793: cap 0: End par conjunct: 0x25265b0 +10642221031: cap 0: End par conjunction: 0x25265b0 +10642221202: cap 0: End par conjunct: 0x2526550 +10642221454: cap 0: running a local spark +10711376500: cap 2: End par conjunct: 0x2521210 +10711378080: cap 2: Trying to steal a spark +10711379547: cap 2: stealing a spark from cap 0 +10727115322: cap 1: End par conjunct: 0x2521270 +10727115952: cap 1: Trying to steal a spark +10727116326: cap 1: stealing a spark from cap 0 +10766963713: cap 3: End par conjunct: 0x25212d0 +10766964159: cap 3: Trying to steal a spark +10766964708: cap 3: stealing a spark from cap 0 +10803763021: cap 0: End par conjunct: 0x2526550 +10803763255: cap 0: End par conjunction: 0x2526550 +10803763669: cap 0: End par conjunct: 0x25264f0 +10803764065: cap 0: running a local spark +10850931634: cap 2: End par conjunct: 0x2521330 +10850932723: cap 2: Trying to steal a spark +10850933682: cap 2: stealing a spark from cap 0 +10871063343: cap 1: End par conjunct: 0x2521390 +10871063959: cap 1: Trying to steal a spark +10871064324: cap 1: stealing a spark from cap 0 +10910143683: cap 3: End par conjunct: 0x25213f0 +10910144070: cap 3: Trying to steal a spark +10910144668: cap 3: stealing a spark from cap 0 +10964218027: cap 0: End par conjunct: 0x25264f0 +10964218221: cap 0: End par conjunction: 0x25264f0 +10964218396: cap 0: End par conjunct: 0x2526490 +10964218648: cap 0: running a local spark +10990676259: cap 2: End par conjunct: 0x2521450 +10990677249: cap 2: Trying to steal a spark +10990677919: cap 2: stealing a spark from cap 0 +11016644328: cap 1: End par conjunct: 0x25214b0 +11016644814: cap 1: Trying to steal a spark +11016645349: cap 1: stealing a spark from cap 0 +11054020212: cap 3: End par conjunct: 0x2521510 +11054020747: cap 3: Trying to steal a spark +11054021283: cap 3: stealing a spark from cap 0 +11124312552: cap 0: End par conjunct: 0x2526490 +11124312741: cap 0: End par conjunction: 0x2526490 +11124312912: cap 0: End par conjunct: 0x2526430 +11124313141: cap 0: running a local spark +11130237697: cap 2: End par conjunct: 0x2521570 +11130238665: cap 2: Trying to steal a spark +11130239587: cap 2: stealing a spark from cap 0 +11166443280: cap 1: End par conjunct: 0x25215d0 +11166443941: cap 1: Trying to steal a spark +11166444351: cap 1: stealing a spark from cap 0 +11198276806: cap 3: End par conjunct: 0x2521630 +11198277180: cap 3: Trying to steal a spark +11198277738: cap 3: stealing a spark from cap 0 +11284699194: cap 0: End par conjunct: 0x2526430 +11284699360: cap 0: End par conjunction: 0x2526430 +11284699513: cap 0: End par conjunct: 0x25263d0 +11284699761: cap 0: running a local spark +11312440254: cap 1: End par conjunct: 0x25216f0 +11312442040: cap 1: Trying to steal a spark +11312444371: cap 1: stealing a spark from cap 0 +11312783883: cap 2: End par conjunct: 0x2521690 +11312784580: cap 2: Trying to steal a spark +11312784972: cap 2: stealing a spark from cap 0 +11342731563: cap 3: End par conjunct: 0x2521750 +11342732139: cap 3: Trying to steal a spark +11342732652: cap 3: stealing a spark from cap 0 +11445803059: cap 0: End par conjunct: 0x25263d0 +11445803433: cap 0: End par conjunction: 0x25263d0 +11445803622: cap 0: End par conjunct: 0x2526370 +11445804027: cap 0: running a local spark +11458751418: cap 1: End par conjunct: 0x25217b0 +11458753222: cap 1: Trying to steal a spark +11458755310: cap 1: stealing a spark from cap 0 +11460625096: cap 2: End par conjunct: 0x2521810 +11460625893: cap 2: Trying to steal a spark +11460626257: cap 2: stealing a spark from cap 0 +11487493503: cap 3: End par conjunct: 0x2521870 +11487493921: cap 3: Trying to steal a spark +11487494565: cap 3: stealing a spark from cap 0 +11601736843: cap 2: End par conjunct: 0x2521930 +11601737851: cap 2: Trying to steal a spark +11601738589: cap 2: stealing a spark from cap 0 +11604598339: cap 1: End par conjunct: 0x25218d0 +11604598888: cap 1: Trying to steal a spark +11604599257: cap 1: stealing a spark from cap 0 +11606569362: cap 0: End par conjunct: 0x2526370 +11606569528: cap 0: End par conjunction: 0x2526370 +11606569825: cap 0: End par conjunct: 0x2526310 +11606570104: cap 0: running a local spark +11633560339: cap 3: End par conjunct: 0x2521990 +11633560816: cap 3: Trying to steal a spark +11633561136: cap 3: stealing a spark from cap 0 +11743114063: cap 2: End par conjunct: 0x25219f0 +11743115157: cap 2: Trying to steal a spark +11743115940: cap 2: stealing a spark from cap 0 +11751459736: cap 1: End par conjunct: 0x2521a50 +11751460425: cap 1: Trying to steal a spark +11751460942: cap 1: stealing a spark from cap 0 +11766982891: cap 0: End par conjunct: 0x2526310 +11766983035: cap 0: End par conjunction: 0x2526310 +11766983175: cap 0: End par conjunct: 0x25262b0 +11766983422: cap 0: running a local spark +11779198884: cap 3: End par conjunct: 0x2521ab0 +11779199352: cap 3: Trying to steal a spark +11779199617: cap 3: stealing a spark from cap 0 +11883866166: cap 2: End par conjunct: 0x2521b10 +11883867021: cap 2: Trying to steal a spark +11883867556: cap 2: stealing a spark from cap 0 +11896785247: cap 1: End par conjunct: 0x2521b70 +11896785634: cap 1: Trying to steal a spark +11896786044: cap 1: stealing a spark from cap 0 +11923061341: cap 3: End par conjunct: 0x2521bd0 +11923061922: cap 3: Trying to steal a spark +11923062372: cap 3: stealing a spark from cap 0 +11926619131: cap 0: End par conjunct: 0x25262b0 +11926619298: cap 0: End par conjunction: 0x25262b0 +11926619428: cap 0: End par conjunct: 0x2526250 +11926619824: cap 0: running a local spark +12024676044: cap 2: End par conjunct: 0x2521c30 +12024677214: cap 2: Trying to steal a spark +12024678789: cap 2: stealing a spark from cap 0 +12041377704: cap 1: End par conjunct: 0x2521c90 +12041378595: cap 1: Trying to steal a spark +12041378955: cap 1: stealing a spark from cap 0 +12086340925: cap 0: End par conjunct: 0x2526250 +12086341938: cap 0: End par conjunction: 0x2526250 +12086342455: cap 0: End par conjunct: 0x25261f0 +12086343774: cap 0: running a local spark +12108682764: cap 3: End par conjunct: 0x2521cf0 +12108683965: cap 3: Trying to steal a spark +12108685653: cap 3: stealing a spark from cap 0 +12164697918: cap 2: End par conjunct: 0x2521d50 +12164699362: cap 2: Trying to steal a spark +12164700856: cap 2: stealing a spark from cap 0 +12184922889: cap 1: End par conjunct: 0x2521db0 +12184923429: cap 1: Trying to steal a spark +12184923888: cap 1: stealing a spark from cap 0 +12251227675: cap 3: End par conjunct: 0x2521e10 +12251229313: cap 3: Trying to steal a spark +12251230870: cap 3: stealing a spark from cap 0 +12251896699: cap 0: End par conjunct: 0x25261f0 +12251897073: cap 0: End par conjunction: 0x25261f0 +12251897343: cap 0: End par conjunct: 0x2526190 +12251897892: cap 0: running a local spark +12302414905: cap 2: End par conjunct: 0x2521e70 +12302415652: cap 2: Trying to steal a spark +12302416246: cap 2: stealing a spark from cap 0 +12333407085: cap 1: End par conjunct: 0x2521ed0 +12333407895: cap 1: Trying to steal a spark +12333408480: cap 1: stealing a spark from cap 0 +12392754678: cap 3: End par conjunct: 0x2521f30 +12392755141: cap 3: Trying to steal a spark +12392755785: cap 3: stealing a spark from cap 0 +12411366187: cap 0: End par conjunct: 0x2526190 +12411366376: cap 0: End par conjunction: 0x2526190 +12411366673: cap 0: End par conjunct: 0x2526130 +12411367051: cap 0: running a local spark +12440491884: cap 2: End par conjunct: 0x2521f90 +12440493301: cap 2: Trying to steal a spark +12440494921: cap 2: stealing a spark from cap 0 +12473435754: cap 1: End par conjunct: 0x2521ff0 +12473436339: cap 1: Trying to steal a spark +12473436748: cap 1: stealing a spark from cap 0 +12530891619: cap 3: End par conjunct: 0x2522050 +12530892181: cap 3: Trying to steal a spark +12530892865: cap 3: stealing a spark from cap 0 +12570819007: cap 0: End par conjunct: 0x2526130 +12570819277: cap 0: End par conjunction: 0x2526130 +12570819453: cap 0: End par conjunct: 0x25260d0 +12570819714: cap 0: running a local spark +12573405976: cap 2: End par conjunct: 0x25220b0 +12573407128: cap 2: Trying to steal a spark +12573407970: cap 2: stealing a spark from cap 0 +12609466533: cap 1: End par conjunct: 0x2522110 +12609468292: cap 1: Trying to steal a spark +12609469975: cap 1: stealing a spark from cap 0 +12665593035: cap 3: End par conjunct: 0x2522170 +12665593894: cap 3: Trying to steal a spark +12665594556: cap 3: stealing a spark from cap 0 +12730098919: cap 0: End par conjunct: 0x25260d0 +12730099153: cap 0: End par conjunction: 0x25260d0 +12730099329: cap 0: End par conjunct: 0x2526070 +12730099702: cap 0: running a local spark +12746089467: cap 1: End par conjunct: 0x2522230 +12746091240: cap 1: Trying to steal a spark +12746093512: cap 1: stealing a spark from cap 0 +12747438603: cap 2: End par conjunct: 0x25221d0 +12747439525: cap 2: Trying to steal a spark +12747439917: cap 2: stealing a spark from cap 0 +12800840445: cap 3: End par conjunct: 0x2522290 +12800841079: cap 3: Trying to steal a spark +12800841687: cap 3: stealing a spark from cap 0 +12882794319: cap 1: End par conjunct: 0x25222f0 +12882795804: cap 1: Trying to steal a spark +12882797946: cap 1: stealing a spark from cap 0 +12885226623: cap 2: End par conjunct: 0x2522350 +12885227482: cap 2: Trying to steal a spark +12885227986: cap 2: stealing a spark from cap 0 +12889340410: cap 0: End par conjunct: 0x2526070 +12889340604: cap 0: End par conjunction: 0x2526070 +12889340775: cap 0: End par conjunct: 0x2526010 +12889341090: cap 0: running a local spark +12936631729: cap 3: End par conjunct: 0x25223b0 +12936632161: cap 3: Trying to steal a spark +12936632440: cap 3: stealing a spark from cap 0 +13016933113: cap 2: End par conjunct: 0x2522470 +13016933599: cap 2: Trying to steal a spark +13016934391: cap 2: stealing a spark from cap 0 +13019456101: cap 1: End par conjunct: 0x2522410 +13019456655: cap 1: Trying to steal a spark +13019457055: cap 1: stealing a spark from cap 0 +13048585978: cap 0: End par conjunct: 0x2526010 +13048586176: cap 0: End par conjunction: 0x2526010 +13048586469: cap 0: End par conjunct: 0x2525fb0 +13048586914: cap 0: running a local spark +13072866543: cap 3: End par conjunct: 0x25224d0 +13072866988: cap 3: Trying to steal a spark +13072867348: cap 3: stealing a spark from cap 0 +13149420961: cap 2: End par conjunct: 0x2522530 +13149421587: cap 2: Trying to steal a spark +13149422266: cap 2: stealing a spark from cap 0 +13156455595: cap 1: End par conjunct: 0x2522590 +13156456378: cap 1: Trying to steal a spark +13156456887: cap 1: stealing a spark from cap 0 +13202327227: cap 0: End par conjunct: 0x2525fb0 +13202327430: cap 0: End par conjunction: 0x2525fb0 +13202327596: cap 0: End par conjunct: 0x2525f50 +13202328006: cap 0: running a local spark +13209541380: cap 3: End par conjunct: 0x25225f0 +13209541816: cap 3: Trying to steal a spark +13209542199: cap 3: stealing a spark from cap 0 +13294576719: cap 2: End par conjunct: 0x2522650 +13294578469: cap 2: Trying to steal a spark +13294580467: cap 2: stealing a spark from cap 0 +13295452455: cap 1: End par conjunct: 0x25226b0 +13295453157: cap 1: Trying to steal a spark +13295453553: cap 1: stealing a spark from cap 0 +13346993713: cap 3: End par conjunct: 0x2522710 +13346994289: cap 3: Trying to steal a spark +13346994838: cap 3: stealing a spark from cap 0 +13361654686: cap 0: End par conjunct: 0x2525f50 +13361654893: cap 0: End par conjunction: 0x2525f50 +13361655055: cap 0: End par conjunct: 0x2525ef0 +13361655514: cap 0: running a local spark +13434790189: cap 1: End par conjunct: 0x25227d0 +13434792075: cap 1: Trying to steal a spark +13434794478: cap 1: stealing a spark from cap 0 +13465013116: cap 2: End par conjunct: 0x2522770 +13465015015: cap 2: Trying to steal a spark +13465016919: cap 2: stealing a spark from cap 0 +13484915806: cap 3: End par conjunct: 0x2522830 +13484916477: cap 3: Trying to steal a spark +13484917336: cap 3: stealing a spark from cap 0 +13519454503: cap 0: End par conjunct: 0x2525ef0 +13519454850: cap 0: End par conjunction: 0x2525ef0 +13519455124: cap 0: End par conjunct: 0x2525e90 +13519455376: cap 0: running a local spark +13579299810: cap 1: End par conjunct: 0x2522890 +13579301457: cap 1: Trying to steal a spark +13579302429: cap 1: stealing a spark from cap 0 +13599378765: cap 2: End par conjunct: 0x25228f0 +13599379377: cap 2: Trying to steal a spark +13599379800: cap 2: stealing a spark from cap 0 +13623892609: cap 3: End par conjunct: 0x2522950 +13623893185: cap 3: Trying to steal a spark +13623893649: cap 3: stealing a spark from cap 0 +13679082040: cap 0: End par conjunct: 0x2525e90 +13679082324: cap 0: End par conjunction: 0x2525e90 +13679082490: cap 0: End par conjunct: 0x2525e30 +13679082742: cap 0: running a local spark +13719399462: cap 1: End par conjunct: 0x25229b0 +13719400780: cap 1: Trying to steal a spark +13719402382: cap 1: stealing a spark from cap 0 +13734837477: cap 2: End par conjunct: 0x2522a10 +13734837954: cap 2: Trying to steal a spark +13734838345: cap 2: stealing a spark from cap 0 +13762870983: cap 3: End par conjunct: 0x2522a70 +13762871401: cap 3: Trying to steal a spark +13762871964: cap 3: stealing a spark from cap 0 +13839696346: cap 0: End par conjunct: 0x2525e30 +13839696603: cap 0: End par conjunction: 0x2525e30 +13839696792: cap 0: End par conjunct: 0x2525dd0 +13839697048: cap 0: running a local spark +13859145571: cap 1: End par conjunct: 0x2522ad0 +13859146750: cap 1: Trying to steal a spark +13859147745: cap 1: stealing a spark from cap 0 +13870250689: cap 2: End par conjunct: 0x2522b30 +13870251175: cap 2: Trying to steal a spark +13870251544: cap 2: stealing a spark from cap 0 +13902688201: cap 3: End par conjunct: 0x2522b90 +13902688687: cap 3: Trying to steal a spark +13902689376: cap 3: stealing a spark from cap 0 +13999707765: cap 1: End par conjunct: 0x2522bf0 +13999709479: cap 1: Trying to steal a spark +13999711612: cap 1: stealing a spark from cap 0 +13999929925: cap 0: End par conjunct: 0x2525dd0 +13999930159: cap 0: End par conjunction: 0x2525dd0 +13999930330: cap 0: End par conjunct: 0x2525d70 +13999930789: cap 0: running a local spark +14044262805: cap 3: End par conjunct: 0x2522cb0 +14044263592: cap 3: Trying to steal a spark +14044264146: cap 3: stealing a spark from cap 0 +14049352827: cap 2: End par conjunct: 0x2522c50 +14049355230: cap 2: Trying to steal a spark +14049357529: cap 2: stealing a spark from cap 0 +14142702411: cap 1: End par conjunct: 0x2522d10 +14142703923: cap 1: Trying to steal a spark +14142705565: cap 1: stealing a spark from cap 0 +14159583769: cap 0: End par conjunct: 0x2525d70 +14159584620: cap 0: End par conjunction: 0x2525d70 +14159585119: cap 0: End par conjunct: 0x2525d10 +14159586640: cap 0: running a local spark +14189476360: cap 2: End par conjunct: 0x2522dd0 +14189477049: cap 2: Trying to steal a spark +14189477629: cap 2: stealing a spark from cap 0 +14204428195: cap 3: End par conjunct: 0x2522d70 +14204429865: cap 3: Trying to steal a spark +14204431737: cap 3: stealing a spark from cap 0 +14285098071: cap 1: End par conjunct: 0x2522e30 +14285098629: cap 1: Trying to steal a spark +14285099290: cap 1: stealing a spark from cap 0 +14319386586: cap 0: End par conjunct: 0x2525d10 +14319386770: cap 0: End par conjunction: 0x2525d10 +14319387045: cap 0: End par conjunct: 0x2525cb0 +14319387364: cap 0: running a local spark +14326496716: cap 2: End par conjunct: 0x2522e90 +14326497346: cap 2: Trying to steal a spark +14326498039: cap 2: stealing a spark from cap 0 +14345105616: cap 3: End par conjunct: 0x2522ef0 +14345106169: cap 3: Trying to steal a spark +14345106669: cap 3: stealing a spark from cap 0 +14426574268: cap 1: End par conjunct: 0x2522f50 +14426574975: cap 1: Trying to steal a spark +14426575848: cap 1: stealing a spark from cap 0 +14463282816: cap 2: End par conjunct: 0x2522fb0 +14463283608: cap 2: Trying to steal a spark +14463284076: cap 2: stealing a spark from cap 0 +14479039764: cap 0: End par conjunct: 0x2525cb0 +14479039966: cap 0: End par conjunction: 0x2525cb0 +14479040124: cap 0: End par conjunct: 0x2525c50 +14479040632: cap 0: running a local spark +14486433358: cap 3: End par conjunct: 0x2523010 +14486433831: cap 3: Trying to steal a spark +14486434155: cap 3: stealing a spark from cap 0 +14568810984: cap 1: End par conjunct: 0x2523070 +14568811731: cap 1: Trying to steal a spark +14568812536: cap 1: stealing a spark from cap 0 +14601411877: cap 2: End par conjunct: 0x25230d0 +14601412935: cap 2: Trying to steal a spark +14601413380: cap 2: stealing a spark from cap 0 +14628823312: cap 3: End par conjunct: 0x2523130 +14628823843: cap 3: Trying to steal a spark +14628824293: cap 3: stealing a spark from cap 0 +14638176405: cap 0: End par conjunct: 0x2525c50 +14638176558: cap 0: End par conjunction: 0x2525c50 +14638176837: cap 0: End par conjunct: 0x2525bf0 +14638177161: cap 0: running a local spark +14712473970: cap 1: End par conjunct: 0x2523190 +14712475869: cap 1: Trying to steal a spark +14712478024: cap 1: stealing a spark from cap 0 +14771506563: cap 3: End par conjunct: 0x2523250 +14771507184: cap 3: Trying to steal a spark +14771507814: cap 3: stealing a spark from cap 0 +14783932206: cap 2: End par conjunct: 0x25231f0 +14783933722: cap 2: Trying to steal a spark +14783935815: cap 2: stealing a spark from cap 0 +14796214938: cap 0: End par conjunct: 0x2525bf0 +14796215145: cap 0: End par conjunction: 0x2525bf0 +14796215320: cap 0: End par conjunct: 0x2525b90 +14796215667: cap 0: running a local spark +14865487227: cap 1: End par conjunct: 0x25232b0 +14865489189: cap 1: Trying to steal a spark +14865491578: cap 1: stealing a spark from cap 0 +14916953641: cap 3: End par conjunct: 0x2523310 +14916954114: cap 3: Trying to steal a spark +14916954879: cap 3: stealing a spark from cap 0 +14933806969: cap 2: End par conjunct: 0x2523370 +14933807860: cap 2: Trying to steal a spark +14933808607: cap 2: stealing a spark from cap 0 +14954455723: cap 0: End par conjunct: 0x2525b90 +14954455980: cap 0: End par conjunction: 0x2525b90 +14954456169: cap 0: End par conjunct: 0x2525b30 +14954456547: cap 0: running a local spark +15012382698: cap 1: End par conjunct: 0x25233d0 +15012383508: cap 1: Trying to steal a spark +15012384228: cap 1: stealing a spark from cap 0 +15062862001: cap 3: End par conjunct: 0x2523430 +15062862519: cap 3: Trying to steal a spark +15062863090: cap 3: stealing a spark from cap 0 +15075263713: cap 2: End par conjunct: 0x2523490 +15075264213: cap 2: Trying to steal a spark +15075264712: cap 2: stealing a spark from cap 0 +15111651541: cap 0: End par conjunct: 0x2525b30 +15111651730: cap 0: End par conjunction: 0x2525b30 +15111651901: cap 0: End par conjunct: 0x2525ad0 +15111652338: cap 0: running a local spark +15159532509: cap 1: End par conjunct: 0x25234f0 +15159532869: cap 1: Trying to steal a spark +15159533517: cap 1: stealing a spark from cap 0 +15209371957: cap 3: End par conjunct: 0x2523550 +15209372385: cap 3: Trying to steal a spark +15209372830: cap 3: stealing a spark from cap 0 +15217142107: cap 2: End par conjunct: 0x25235b0 +15217142562: cap 2: Trying to steal a spark +15217143066: cap 2: stealing a spark from cap 0 +15269150128: cap 0: End par conjunct: 0x2525ad0 +15269150335: cap 0: End par conjunction: 0x2525ad0 +15269150470: cap 0: End par conjunct: 0x2525a70 +15269150875: cap 0: running a local spark +15307307370: cap 1: End par conjunct: 0x2523610 +15307308000: cap 1: Trying to steal a spark +15307308598: cap 1: stealing a spark from cap 0 +15356259828: cap 3: End par conjunct: 0x2523670 +15356260264: cap 3: Trying to steal a spark +15356260719: cap 3: stealing a spark from cap 0 +15359061276: cap 2: End par conjunct: 0x25236d0 +15359062068: cap 2: Trying to steal a spark +15359062869: cap 2: stealing a spark from cap 0 +15426181422: cap 0: End par conjunct: 0x2525a70 +15426181611: cap 0: End par conjunction: 0x2525a70 +15426181777: cap 0: End par conjunct: 0x2525a10 +15426182079: cap 0: running a local spark +15454049139: cap 1: End par conjunct: 0x2523730 +15454049773: cap 1: Trying to steal a spark +15454050367: cap 1: stealing a spark from cap 0 +15499701720: cap 2: End par conjunct: 0x25237f0 +15499702341: cap 2: Trying to steal a spark +15499702908: cap 2: stealing a spark from cap 0 +15501423757: cap 3: End par conjunct: 0x2523790 +15501424230: cap 3: Trying to steal a spark +15501424765: cap 3: stealing a spark from cap 0 +15583032742: cap 0: End par conjunct: 0x2525a10 +15583032940: cap 0: End par conjunction: 0x2525a10 +15583033129: cap 0: End par conjunct: 0x25259b0 +15583033386: cap 0: running a local spark +15599108277: cap 1: End par conjunct: 0x2523850 +15599109303: cap 1: Trying to steal a spark +15599110086: cap 1: stealing a spark from cap 0 +15640560369: cap 2: End par conjunct: 0x25238b0 +15640561480: cap 2: Trying to steal a spark +15640562115: cap 2: stealing a spark from cap 0 +15646349893: cap 3: End par conjunct: 0x2523910 +15646350348: cap 3: Trying to steal a spark +15646350793: cap 3: stealing a spark from cap 0 +15739566930: cap 0: End par conjunct: 0x25259b0 +15739567137: cap 0: End par conjunction: 0x25259b0 +15739567308: cap 0: End par conjunct: 0x2525950 +15739567560: cap 0: running a local spark +15745644837: cap 1: End par conjunct: 0x2523970 +15745645597: cap 1: Trying to steal a spark +15745646556: cap 1: stealing a spark from cap 0 +15781384827: cap 2: End par conjunct: 0x25239d0 +15781385376: cap 2: Trying to steal a spark +15781385727: cap 2: stealing a spark from cap 0 +15791739669: cap 3: End par conjunct: 0x2523a30 +15791740051: cap 3: Trying to steal a spark +15791740510: cap 3: stealing a spark from cap 0 +15892384153: cap 1: End par conjunct: 0x2523a90 +15892385337: cap 1: Trying to steal a spark +15892386390: cap 1: stealing a spark from cap 0 +15896202012: cap 0: End par conjunct: 0x2525950 +15896202246: cap 0: End par conjunction: 0x2525950 +15896202421: cap 0: End par conjunct: 0x25258f0 +15896202997: cap 0: running a local spark +15924082396: cap 2: End par conjunct: 0x2523af0 +15924083310: cap 2: Trying to steal a spark +15924083980: cap 2: stealing a spark from cap 0 +15937728102: cap 3: End par conjunct: 0x2523b50 +15937728588: cap 3: Trying to steal a spark +15937729150: cap 3: stealing a spark from cap 0 +16045001689: cap 1: End par conjunct: 0x2523bb0 +16045003084: cap 1: Trying to steal a spark +16045004160: cap 1: stealing a spark from cap 0 +16053299329: cap 0: End par conjunct: 0x25258f0 +16053299523: cap 0: End par conjunction: 0x25258f0 +16053299671: cap 0: End par conjunct: 0x2525890 +16053299982: cap 0: running a local spark +16066608561: cap 2: End par conjunct: 0x2523c10 +16066609231: cap 2: Trying to steal a spark +16066609744: cap 2: stealing a spark from cap 0 +16084188706: cap 3: End par conjunct: 0x2523c70 +16084189174: cap 3: Trying to steal a spark +16084189714: cap 3: stealing a spark from cap 0 +16193615319: cap 1: End par conjunct: 0x2523cd0 +16193616453: cap 1: Trying to steal a spark +16193617564: cap 1: stealing a spark from cap 0 +16210622965: cap 0: End par conjunct: 0x2525890 +16210623222: cap 0: End par conjunction: 0x2525890 +16210623411: cap 0: End par conjunct: 0x2525830 +16210623978: cap 0: running a local spark +16210819453: cap 2: End par conjunct: 0x2523d30 +16210819912: cap 2: Trying to steal a spark +16210820493: cap 2: stealing a spark from cap 0 +16232694493: cap 3: End par conjunct: 0x2523d90 +16232695141: cap 3: Trying to steal a spark +16232695753: cap 3: stealing a spark from cap 0 +16342119135: cap 1: End par conjunct: 0x2523df0 +16342120183: cap 1: Trying to steal a spark +16342120809: cap 1: stealing a spark from cap 0 +16354987947: cap 2: End par conjunct: 0x2523e50 +16354988622: cap 2: Trying to steal a spark +16354988977: cap 2: stealing a spark from cap 0 +16367815017: cap 0: End par conjunct: 0x2525830 +16367815350: cap 0: End par conjunction: 0x2525830 +16367815525: cap 0: End par conjunct: 0x25257d0 +16367815836: cap 0: running a local spark +16380890707: cap 3: End par conjunct: 0x2523eb0 +16380891310: cap 3: Trying to steal a spark +16380891652: cap 3: stealing a spark from cap 0 +16492019895: cap 1: End par conjunct: 0x2523f10 +16492020795: cap 1: Trying to steal a spark +16492021740: cap 1: stealing a spark from cap 0 +16499029032: cap 2: End par conjunct: 0x2523f70 +16499029392: cap 2: Trying to steal a spark +16499029711: cap 2: stealing a spark from cap 0 +16524922896: cap 0: End par conjunct: 0x25257d0 +16524923058: cap 0: End par conjunction: 0x25257d0 +16524923215: cap 0: End par conjunct: 0x2525770 +16524923607: cap 0: running a local spark +16529886841: cap 3: End par conjunct: 0x2523fd0 +16529887332: cap 3: Trying to steal a spark +16529887768: cap 3: stealing a spark from cap 0 +16642523817: cap 1: End par conjunct: 0x2524030 +16642524627: cap 1: Trying to steal a spark +16642525428: cap 1: stealing a spark from cap 0 +16643228026: cap 2: End par conjunct: 0x2524090 +16643228620: cap 2: Trying to steal a spark +16643228958: cap 2: stealing a spark from cap 0 +16680950910: cap 0: End par conjunct: 0x2525770 +16680951099: cap 0: End par conjunction: 0x2525770 +16680951247: cap 0: End par conjunct: 0x2525710 +16680951499: cap 0: running a local spark +16682200146: cap 3: End par conjunct: 0x25240f0 +16682200569: cap 3: Trying to steal a spark +16682200947: cap 3: stealing a spark from cap 0 +16793102727: cap 2: End par conjunct: 0x25241b0 +16793103429: cap 2: Trying to steal a spark +16793104441: cap 2: stealing a spark from cap 0 +16797486150: cap 1: End par conjunct: 0x2524150 +16797486825: cap 1: Trying to steal a spark +16797487225: cap 1: stealing a spark from cap 0 +16836621975: cap 0: End par conjunct: 0x2525710 +16836622141: cap 0: End par conjunction: 0x2525710 +16836622321: cap 0: End par conjunct: 0x25256b0 +16836622663: cap 0: running a local spark +16837625277: cap 3: End par conjunct: 0x2524210 +16837625754: cap 3: Trying to steal a spark +16837626159: cap 3: stealing a spark from cap 0 +16945347280: cap 2: End par conjunct: 0x2524270 +16945348770: cap 2: Trying to steal a spark +16945349895: cap 2: stealing a spark from cap 0 +16955697573: cap 1: End par conjunct: 0x25242d0 +16955698000: cap 1: Trying to steal a spark +16955698558: cap 1: stealing a spark from cap 0 +16992188572: cap 0: End par conjunct: 0x25256b0 +16992188766: cap 0: End par conjunction: 0x25256b0 +16992188968: cap 0: End par conjunct: 0x2525650 +16992189297: cap 0: running a local spark +16996860166: cap 3: End par conjunct: 0x2524330 +16996860612: cap 3: Trying to steal a spark +16996860994: cap 3: stealing a spark from cap 0 +17100326358: cap 2: End par conjunct: 0x2524390 +17100327078: cap 2: Trying to steal a spark +17100327775: cap 2: stealing a spark from cap 0 +17121939421: cap 1: End par conjunct: 0x25243f0 +17121940146: cap 1: Trying to steal a spark +17121940542: cap 1: stealing a spark from cap 0 +17147488131: cap 0: End par conjunct: 0x2525650 +17147488477: cap 0: End par conjunction: 0x2525650 +17147488635: cap 0: End par conjunct: 0x25255f0 +17147489058: cap 0: running a local spark +17156473344: cap 3: End par conjunct: 0x2524450 +17156473798: cap 3: Trying to steal a spark +17156474167: cap 3: stealing a spark from cap 0 +17257222408: cap 2: End par conjunct: 0x25244b0 +17257223875: cap 2: Trying to steal a spark +17257225095: cap 2: stealing a spark from cap 0 +17283512254: cap 1: End par conjunct: 0x2524510 +17283513100: cap 1: Trying to steal a spark +17283513496: cap 1: stealing a spark from cap 0 +17303152891: cap 0: End par conjunct: 0x25255f0 +17303153125: cap 0: End par conjunction: 0x25255f0 +17303153301: cap 0: End par conjunct: 0x2525590 +17303153638: cap 0: running a local spark +17317260342: cap 3: End par conjunct: 0x2524570 +17317260765: cap 3: Trying to steal a spark +17317261179: cap 3: stealing a spark from cap 0 +17413679826: cap 2: End par conjunct: 0x25245d0 +17413680730: cap 2: Trying to steal a spark +17413681639: cap 2: stealing a spark from cap 0 +17445166501: cap 1: End par conjunct: 0x2524630 +17445167343: cap 1: Trying to steal a spark +17445167896: cap 1: stealing a spark from cap 0 +17459300466: cap 0: End par conjunct: 0x2525590 +17459301208: cap 0: End par conjunction: 0x2525590 +17459301870: cap 0: End par conjunct: 0x2525530 +17459303044: cap 0: running a local spark +17482807381: cap 3: End par conjunct: 0x2524690 +17482808547: cap 3: Trying to steal a spark +17482809829: cap 3: stealing a spark from cap 0 +17569003230: cap 2: End par conjunct: 0x25246f0 +17569004233: cap 2: Trying to steal a spark +17569004854: cap 2: stealing a spark from cap 0 +17605677370: cap 1: End par conjunct: 0x2524750 +17605677892: cap 1: Trying to steal a spark +17605678446: cap 1: stealing a spark from cap 0 +17615119162: cap 0: End par conjunct: 0x2525530 +17615120013: cap 0: End par conjunction: 0x2525530 +17615120620: cap 0: End par conjunct: 0x25254d0 +17615121957: cap 0: running a local spark +17686208227: cap 3: End par conjunct: 0x25247b0 +17686209937: cap 3: Trying to steal a spark +17686211638: cap 3: stealing a spark from cap 0 +17725139019: cap 2: End par conjunct: 0x2524810 +17725140454: cap 2: Trying to steal a spark +17725141692: cap 2: stealing a spark from cap 0 +17767218150: cap 1: End par conjunct: 0x2524870 +17767218951: cap 1: Trying to steal a spark +17767219387: cap 1: stealing a spark from cap 0 +17770340709: cap 0: End par conjunct: 0x25254d0 +17770340929: cap 0: End par conjunction: 0x25254d0 +17770341208: cap 0: End par conjunct: 0x2525470 +17770341649: cap 0: running a local spark +17846979615: cap 3: End par conjunct: 0x25248d0 +17846980263: cap 3: Trying to steal a spark +17846980960: cap 3: stealing a spark from cap 0 +17882204926: cap 2: End par conjunct: 0x2524930 +17882206677: cap 2: Trying to steal a spark +17882208459: cap 2: stealing a spark from cap 0 +17925635443: cap 0: End par conjunct: 0x2525470 +17925635695: cap 0: End par conjunction: 0x2525470 +17925635983: cap 0: End par conjunct: 0x2525410 +17925636316: cap 0: running a local spark +17929204371: cap 1: End par conjunct: 0x2524990 +17929205428: cap 1: Trying to steal a spark +17929206256: cap 1: stealing a spark from cap 0 +18007752343: cap 3: End par conjunct: 0x25249f0 +18007752766: cap 3: Trying to steal a spark +18007753437: cap 3: stealing a spark from cap 0 +18038756245: cap 2: End par conjunct: 0x2524a50 +18038757163: cap 2: Trying to steal a spark +18038757798: cap 2: stealing a spark from cap 0 +18080380548: cap 0: End par conjunct: 0x2525410 +18080380750: cap 0: End par conjunction: 0x2525410 +18080380926: cap 0: End par conjunct: 0x25253b0 +18080381268: cap 0: running a local spark +18090447849: cap 1: End par conjunct: 0x2524ab0 +18090448285: cap 1: Trying to steal a spark +18090448825: cap 1: stealing a spark from cap 0 +18168395116: cap 3: End par conjunct: 0x2524b10 +18168395557: cap 3: Trying to steal a spark +18168396106: cap 3: stealing a spark from cap 0 +18194295892: cap 2: End par conjunct: 0x2524b70 +18194296734: cap 2: Trying to steal a spark +18194297454: cap 2: stealing a spark from cap 0 +18235582875: cap 0: End par conjunct: 0x25253b0 +18235583064: cap 0: End par conjunction: 0x25253b0 +18235583217: cap 0: End par conjunct: 0x2525350 +18235583536: cap 0: running a local spark +18251847418: cap 1: End par conjunct: 0x2524bd0 +18251847949: cap 1: Trying to steal a spark +18251848642: cap 1: stealing a spark from cap 0 +18328247212: cap 3: End par conjunct: 0x2524c30 +18328247581: cap 3: Trying to steal a spark +18328248135: cap 3: stealing a spark from cap 0 +18349427848: cap 2: End par conjunct: 0x2524c90 +18349428879: cap 2: Trying to steal a spark +18349429522: cap 2: stealing a spark from cap 0 +18390413767: cap 0: End par conjunct: 0x2525350 +18390414015: cap 0: End par conjunction: 0x2525350 +18390414307: cap 0: End par conjunct: 0x25252f0 +18390414771: cap 0: running a local spark +18418554441: cap 1: End par conjunct: 0x2524cf0 +18418556151: cap 1: Trying to steal a spark +18418558081: cap 1: stealing a spark from cap 0 +18488594830: cap 3: End par conjunct: 0x2524d50 +18488595802: cap 3: Trying to steal a spark +18488596576: cap 3: stealing a spark from cap 0 +18545712619: cap 0: End par conjunct: 0x25252f0 +18545712975: cap 0: End par conjunction: 0x25252f0 +18545713146: cap 0: End par conjunct: 0x2525290 +18545713398: cap 0: running a local spark +18548312062: cap 2: End par conjunct: 0x2524db0 +18548314159: cap 2: Trying to steal a spark +18548316522: cap 2: stealing a spark from cap 0 +18581090584: cap 1: End par conjunct: 0x2524e10 +18581091916: cap 1: Trying to steal a spark +18581092528: cap 1: stealing a spark from cap 0 +18647874999: cap 3: End par conjunct: 0x2524e70 +18647876155: cap 3: Trying to steal a spark +18647877249: cap 3: stealing a spark from cap 0 +18701289085: cap 0: End par conjunct: 0x2525290 +18701289450: cap 0: End par conjunction: 0x2525290 +18701289634: cap 0: End par conjunct: 0x2525230 +18701290008: cap 0: running a local spark +18709436227: cap 2: End par conjunct: 0x2524ed0 +18709437973: cap 2: Trying to steal a spark +18709439710: cap 2: stealing a spark from cap 0 +18740173275: cap 1: End par conjunct: 0x2524f30 +18740174184: cap 1: Trying to steal a spark +18740174580: cap 1: stealing a spark from cap 0 +18805391203: cap 3: End par conjunct: 0x2524f90 +18805391730: cap 3: Trying to steal a spark +18805392283: cap 3: stealing a spark from cap 0 +18855587983: cap 0: End par conjunct: 0x2525230 +18855588177: cap 0: End par conjunction: 0x2525230 +18855588330: cap 0: End par conjunct: 0x25251d0 +18855588541: cap 0: running a local spark +18861182568: cap 2: End par conjunct: 0x2524ff0 +18861183427: cap 2: Trying to steal a spark +18861184143: cap 2: stealing a spark from cap 0 +18895434813: cap 1: End par conjunct: 0x2525050 +18895435393: cap 1: Trying to steal a spark +18895435798: cap 1: stealing a spark from cap 0 +18959237212: cap 3: End par conjunct: 0x25250b0 +18959238031: cap 3: Trying to steal a spark +18959238990: cap 3: Looking for global thread to resume +19010127069: cap 0: End par conjunct: 0x25251d0 +19010127645: cap 0: End par conjunction: 0x25251d0 +19010128009: cap 0: End par conjunct: 0x2525170 +19010128540: cap 0: Trying to steal a spark +19010134809: cap 0: stopping thread 1 (thread blocked) +19010135358: cap 0: Looking for global thread to resume +19010337894: cap 2: End par conjunct: 0x2525110 +19010338645: cap 2: Trying to steal a spark +19010339802: cap 2: Looking for global thread to resume +19050343357: cap 1: End par conjunct: 0x2525170 +19050344109: cap 1: stopping thread 4 (thread finished) +19050349639: cap 1: thread 1 is runnable +19050352011: cap 1: Releasing thread 4 to the free pool +19050353118: cap 1: running thread 1 +19050353397: cap 1: End par conjunction: 0x2525170 +19050353689: cap 1: End par conjunct: 0x2525110 +19050353869: cap 1: End par conjunction: 0x2525110 +19050354108: cap 1: End par conjunct: 0x25250b0 +19050354238: cap 1: End par conjunction: 0x25250b0 +19050354409: cap 1: End par conjunct: 0x2525050 +19050354535: cap 1: End par conjunction: 0x2525050 +19050354666: cap 1: End par conjunct: 0x2524ff0 +19050354801: cap 1: End par conjunction: 0x2524ff0 +19050355021: cap 1: End par conjunct: 0x2524f90 +19050355345: cap 1: End par conjunction: 0x2524f90 +19050355494: cap 1: End par conjunct: 0x2524f30 +19050355620: cap 1: End par conjunction: 0x2524f30 +19050369354: cap 1: End par conjunct: 0x2524ed0 +19050369520: cap 1: End par conjunction: 0x2524ed0 +19050369709: cap 1: End par conjunct: 0x2524e70 +19050369849: cap 1: End par conjunction: 0x2524e70 +19050370087: cap 1: End par conjunct: 0x2524e10 +19050370299: cap 1: End par conjunction: 0x2524e10 +19050370429: cap 1: End par conjunct: 0x2524db0 +19050370564: cap 1: End par conjunction: 0x2524db0 +19050370699: cap 1: End par conjunct: 0x2524d50 +19050370825: cap 1: End par conjunction: 0x2524d50 +19050370960: cap 1: End par conjunct: 0x2524cf0 +19050371086: cap 1: End par conjunction: 0x2524cf0 +19050371221: cap 1: End par conjunct: 0x2524c90 +19050371352: cap 1: End par conjunction: 0x2524c90 +19050371482: cap 1: End par conjunct: 0x2524c30 +19050371613: cap 1: End par conjunction: 0x2524c30 +19050371739: cap 1: End par conjunct: 0x2524bd0 +19050371874: cap 1: End par conjunction: 0x2524bd0 +19050372004: cap 1: End par conjunct: 0x2524b70 +19050372130: cap 1: End par conjunction: 0x2524b70 +19050372306: cap 1: End par conjunct: 0x2524b10 +19050372445: cap 1: End par conjunction: 0x2524b10 +19050372576: cap 1: End par conjunct: 0x2524ab0 +19050372702: cap 1: End par conjunction: 0x2524ab0 +19050372828: cap 1: End par conjunct: 0x2524a50 +19050372958: cap 1: End par conjunction: 0x2524a50 +19050373147: cap 1: End par conjunct: 0x25249f0 +19050373273: cap 1: End par conjunction: 0x25249f0 +19050373458: cap 1: End par conjunct: 0x2524990 +19050373584: cap 1: End par conjunction: 0x2524990 +19050373714: cap 1: End par conjunct: 0x2524930 +19050373849: cap 1: End par conjunction: 0x2524930 +19050373975: cap 1: End par conjunct: 0x25248d0 +19050374101: cap 1: End par conjunction: 0x25248d0 +19050374232: cap 1: End par conjunct: 0x2524870 +19050374367: cap 1: End par conjunction: 0x2524870 +19050374497: cap 1: End par conjunct: 0x2524810 +19050374623: cap 1: End par conjunction: 0x2524810 +19050374749: cap 1: End par conjunct: 0x25247b0 +19050374997: cap 1: End par conjunction: 0x25247b0 +19050375127: cap 1: End par conjunct: 0x2524750 +19050375258: cap 1: End par conjunction: 0x2524750 +19050375505: cap 1: End par conjunct: 0x25246f0 +19050375627: cap 1: End par conjunction: 0x25246f0 +19050375762: cap 1: End par conjunct: 0x2524690 +19050375892: cap 1: End par conjunction: 0x2524690 +19050376023: cap 1: End par conjunct: 0x2524630 +19050376153: cap 1: End par conjunction: 0x2524630 +19050376279: cap 1: End par conjunct: 0x25245d0 +19050376414: cap 1: End par conjunction: 0x25245d0 +19050376540: cap 1: End par conjunct: 0x2524570 +19050376671: cap 1: End par conjunction: 0x2524570 +19050376797: cap 1: End par conjunct: 0x2524510 +19050376932: cap 1: End par conjunction: 0x2524510 +19050377062: cap 1: End par conjunct: 0x25244b0 +19050377188: cap 1: End par conjunction: 0x25244b0 +19050377314: cap 1: End par conjunct: 0x2524450 +19050377440: cap 1: End par conjunction: 0x2524450 +19050377571: cap 1: End par conjunct: 0x25243f0 +19050377697: cap 1: End par conjunction: 0x25243f0 +19050377827: cap 1: End par conjunct: 0x2524390 +19050377949: cap 1: End par conjunction: 0x2524390 +19050378079: cap 1: End par conjunct: 0x2524330 +19050378210: cap 1: End par conjunction: 0x2524330 +19050378340: cap 1: End par conjunct: 0x25242d0 +19050378466: cap 1: End par conjunction: 0x25242d0 +19050378597: cap 1: End par conjunct: 0x2524270 +19050378727: cap 1: End par conjunction: 0x2524270 +19050378858: cap 1: End par conjunct: 0x2524210 +19050378984: cap 1: End par conjunction: 0x2524210 +19050379110: cap 1: End par conjunct: 0x25241b0 +19050379245: cap 1: End par conjunction: 0x25241b0 +19050379375: cap 1: End par conjunct: 0x2524150 +19050379506: cap 1: End par conjunction: 0x2524150 +19050379636: cap 1: End par conjunct: 0x25240f0 +19050379762: cap 1: End par conjunction: 0x25240f0 +19050379897: cap 1: End par conjunct: 0x2524090 +19050380023: cap 1: End par conjunction: 0x2524090 +19050380158: cap 1: End par conjunct: 0x2524030 +19050380280: cap 1: End par conjunction: 0x2524030 +19050380406: cap 1: End par conjunct: 0x2523fd0 +19050380712: cap 1: End par conjunction: 0x2523fd0 +19050380959: cap 1: End par conjunct: 0x2523f70 +19050381207: cap 1: End par conjunction: 0x2523f70 +19050381333: cap 1: End par conjunct: 0x2523f10 +19050381472: cap 1: End par conjunction: 0x2523f10 +19050381603: cap 1: End par conjunct: 0x2523eb0 +19050381724: cap 1: End par conjunction: 0x2523eb0 +19050381855: cap 1: End par conjunct: 0x2523e50 +19050381981: cap 1: End par conjunction: 0x2523e50 +19050382111: cap 1: End par conjunct: 0x2523df0 +19050382237: cap 1: End par conjunction: 0x2523df0 +19050382368: cap 1: End par conjunct: 0x2523d90 +19050382494: cap 1: End par conjunction: 0x2523d90 +19050382629: cap 1: End par conjunct: 0x2523d30 +19050382755: cap 1: End par conjunction: 0x2523d30 +19050382885: cap 1: End par conjunct: 0x2523cd0 +19050383007: cap 1: End par conjunction: 0x2523cd0 +19050383142: cap 1: End par conjunct: 0x2523c70 +19050383277: cap 1: End par conjunction: 0x2523c70 +19050383407: cap 1: End par conjunct: 0x2523c10 +19050383533: cap 1: End par conjunction: 0x2523c10 +19050383668: cap 1: End par conjunct: 0x2523bb0 +19050383799: cap 1: End par conjunction: 0x2523bb0 +19050383929: cap 1: End par conjunct: 0x2523b50 +19050384055: cap 1: End par conjunction: 0x2523b50 +19050384195: cap 1: End par conjunct: 0x2523af0 +19050384321: cap 1: End par conjunction: 0x2523af0 +19050384451: cap 1: End par conjunct: 0x2523a90 +19050384577: cap 1: End par conjunction: 0x2523a90 +19050384726: cap 1: End par conjunct: 0x2523a30 +19050384852: cap 1: End par conjunction: 0x2523a30 +19050384978: cap 1: End par conjunct: 0x25239d0 +19050385113: cap 1: End par conjunction: 0x25239d0 +19050385243: cap 1: End par conjunct: 0x2523970 +19050385374: cap 1: End par conjunction: 0x2523970 +19050385495: cap 1: End par conjunct: 0x2523910 +19050385630: cap 1: End par conjunction: 0x2523910 +19050385761: cap 1: End par conjunct: 0x25238b0 +19050385887: cap 1: End par conjunction: 0x25238b0 +19050386013: cap 1: End par conjunct: 0x2523850 +19050386143: cap 1: End par conjunction: 0x2523850 +19050386274: cap 1: End par conjunct: 0x25237f0 +19050386400: cap 1: End par conjunction: 0x25237f0 +19050386535: cap 1: End par conjunct: 0x2523790 +19050386661: cap 1: End par conjunction: 0x2523790 +19050386787: cap 1: End par conjunct: 0x2523730 +19050386917: cap 1: End par conjunction: 0x2523730 +19050387043: cap 1: End par conjunct: 0x25236d0 +19050387169: cap 1: End par conjunction: 0x25236d0 +19050387295: cap 1: End par conjunct: 0x2523670 +19050387430: cap 1: End par conjunction: 0x2523670 +19050387561: cap 1: End par conjunct: 0x2523610 +19050387687: cap 1: End par conjunction: 0x2523610 +19050387817: cap 1: End par conjunct: 0x25235b0 +19050387948: cap 1: End par conjunction: 0x25235b0 +19050388078: cap 1: End par conjunct: 0x2523550 +19050388209: cap 1: End par conjunction: 0x2523550 +19050388344: cap 1: End par conjunct: 0x25234f0 +19050388465: cap 1: End par conjunction: 0x25234f0 +19050388596: cap 1: End par conjunct: 0x2523490 +19050388726: cap 1: End par conjunction: 0x2523490 +19050388857: cap 1: End par conjunct: 0x2523430 +19050388987: cap 1: End par conjunction: 0x2523430 +19050389113: cap 1: End par conjunct: 0x25233d0 +19050389248: cap 1: End par conjunction: 0x25233d0 +19050389374: cap 1: End par conjunct: 0x2523370 +19050389505: cap 1: End par conjunction: 0x2523370 +19050389631: cap 1: End par conjunct: 0x2523310 +19050389766: cap 1: End par conjunction: 0x2523310 +19050389901: cap 1: End par conjunct: 0x25232b0 +19050390027: cap 1: End par conjunction: 0x25232b0 +19050390153: cap 1: End par conjunct: 0x2523250 +19050390283: cap 1: End par conjunction: 0x2523250 +19050390414: cap 1: End par conjunct: 0x25231f0 +19050390540: cap 1: End par conjunction: 0x25231f0 +19050390670: cap 1: End par conjunct: 0x2523190 +19050390796: cap 1: End par conjunction: 0x2523190 +19050390927: cap 1: End par conjunct: 0x2523130 +19050391053: cap 1: End par conjunction: 0x2523130 +19050391183: cap 1: End par conjunct: 0x25230d0 +19050391305: cap 1: End par conjunction: 0x25230d0 +19050391476: cap 1: End par conjunct: 0x2523070 +19050391611: cap 1: End par conjunction: 0x2523070 +19050391741: cap 1: End par conjunct: 0x2523010 +19050391858: cap 1: End par conjunction: 0x2523010 +19050392101: cap 1: End par conjunct: 0x2522fb0 +19050392407: cap 1: End par conjunction: 0x2522fb0 +19050392538: cap 1: End par conjunct: 0x2522f50 +19050392749: cap 1: End par conjunction: 0x2522f50 +19050392884: cap 1: End par conjunct: 0x2522ef0 +19050393010: cap 1: End par conjunction: 0x2522ef0 +19050393141: cap 1: End par conjunct: 0x2522e90 +19050393271: cap 1: End par conjunction: 0x2522e90 +19050393402: cap 1: End par conjunct: 0x2522e30 +19050393528: cap 1: End par conjunction: 0x2522e30 +19050393658: cap 1: End par conjunct: 0x2522dd0 +19050393793: cap 1: End par conjunction: 0x2522dd0 +19050393919: cap 1: End par conjunct: 0x2522d70 +19050394045: cap 1: End par conjunction: 0x2522d70 +19050394176: cap 1: End par conjunct: 0x2522d10 +19050394311: cap 1: End par conjunction: 0x2522d10 +19050394446: cap 1: End par conjunct: 0x2522cb0 +19050394567: cap 1: End par conjunction: 0x2522cb0 +19050394698: cap 1: End par conjunct: 0x2522c50 +19050394824: cap 1: End par conjunction: 0x2522c50 +19050394954: cap 1: End par conjunct: 0x2522bf0 +19050395080: cap 1: End par conjunction: 0x2522bf0 +19050395211: cap 1: End par conjunct: 0x2522b90 +19050395332: cap 1: End par conjunction: 0x2522b90 +19050395467: cap 1: End par conjunct: 0x2522b30 +19050395598: cap 1: End par conjunction: 0x2522b30 +19050395724: cap 1: End par conjunct: 0x2522ad0 +19050395850: cap 1: End par conjunction: 0x2522ad0 +19050395985: cap 1: End par conjunct: 0x2522a70 +19050396120: cap 1: End par conjunction: 0x2522a70 +19050396246: cap 1: End par conjunct: 0x2522a10 +19050396372: cap 1: End par conjunction: 0x2522a10 +19050396507: cap 1: End par conjunct: 0x25229b0 +19050396642: cap 1: End par conjunction: 0x25229b0 +19050396772: cap 1: End par conjunct: 0x2522950 +19050396898: cap 1: End par conjunction: 0x2522950 +19050397042: cap 1: End par conjunct: 0x25228f0 +19050397168: cap 1: End par conjunction: 0x25228f0 +19050397299: cap 1: End par conjunct: 0x2522890 +19050397429: cap 1: End par conjunction: 0x2522890 +19050397573: cap 1: End par conjunct: 0x2522830 +19050397704: cap 1: End par conjunction: 0x2522830 +19050397830: cap 1: End par conjunct: 0x25227d0 +19050397965: cap 1: End par conjunction: 0x25227d0 +19050398095: cap 1: End par conjunct: 0x2522770 +19050398221: cap 1: End par conjunction: 0x2522770 +19050398347: cap 1: End par conjunct: 0x2522710 +19050398482: cap 1: End par conjunction: 0x2522710 +19050398617: cap 1: End par conjunct: 0x25226b0 +19050398743: cap 1: End par conjunction: 0x25226b0 +19050398869: cap 1: End par conjunct: 0x2522650 +19050399000: cap 1: End par conjunction: 0x2522650 +19050399130: cap 1: End par conjunct: 0x25225f0 +19050399256: cap 1: End par conjunction: 0x25225f0 +19050399387: cap 1: End par conjunct: 0x2522590 +19050399513: cap 1: End par conjunction: 0x2522590 +19050399648: cap 1: End par conjunct: 0x2522530 +19050399774: cap 1: End par conjunction: 0x2522530 +19050399904: cap 1: End par conjunct: 0x25224d0 +19050400026: cap 1: End par conjunction: 0x25224d0 +19050400161: cap 1: End par conjunct: 0x2522470 +19050400296: cap 1: End par conjunction: 0x2522470 +19050400422: cap 1: End par conjunct: 0x2522410 +19050400548: cap 1: End par conjunction: 0x2522410 +19050400683: cap 1: End par conjunct: 0x25223b0 +19050400813: cap 1: End par conjunction: 0x25223b0 +19050400944: cap 1: End par conjunct: 0x2522350 +19050401070: cap 1: End par conjunction: 0x2522350 +19050401205: cap 1: End par conjunct: 0x25222f0 +19050401331: cap 1: End par conjunction: 0x25222f0 +19050401461: cap 1: End par conjunct: 0x2522290 +19050401592: cap 1: End par conjunction: 0x2522290 +19050401740: cap 1: End par conjunct: 0x2522230 +19050401866: cap 1: End par conjunction: 0x2522230 +19050401992: cap 1: End par conjunct: 0x25221d0 +19050402127: cap 1: End par conjunction: 0x25221d0 +19050402258: cap 1: End par conjunct: 0x2522170 +19050402384: cap 1: End par conjunction: 0x2522170 +19050402510: cap 1: End par conjunct: 0x2522110 +19050402649: cap 1: End par conjunction: 0x2522110 +19050402780: cap 1: End par conjunct: 0x25220b0 +19050403014: cap 1: End par conjunction: 0x25220b0 +19050403140: cap 1: End par conjunct: 0x2522050 +19050403261: cap 1: End par conjunction: 0x2522050 +19050403396: cap 1: End par conjunct: 0x2521ff0 +19050403639: cap 1: End par conjunction: 0x2521ff0 +19050403770: cap 1: End par conjunct: 0x2521f90 +19050403896: cap 1: End par conjunction: 0x2521f90 +19050404035: cap 1: End par conjunct: 0x2521f30 +19050404170: cap 1: End par conjunction: 0x2521f30 +19050404301: cap 1: End par conjunct: 0x2521ed0 +19050404427: cap 1: End par conjunction: 0x2521ed0 +19050404553: cap 1: End par conjunct: 0x2521e70 +19050404683: cap 1: End par conjunction: 0x2521e70 +19050404814: cap 1: End par conjunct: 0x2521e10 +19050404940: cap 1: End par conjunction: 0x2521e10 +19050405075: cap 1: End par conjunct: 0x2521db0 +19050405205: cap 1: End par conjunction: 0x2521db0 +19050405336: cap 1: End par conjunct: 0x2521d50 +19050405466: cap 1: End par conjunction: 0x2521d50 +19050405709: cap 1: End par conjunct: 0x2521cf0 +19050405835: cap 1: End par conjunction: 0x2521cf0 +19050405966: cap 1: End par conjunct: 0x2521c90 +19050406096: cap 1: End par conjunction: 0x2521c90 +19050406344: cap 1: End par conjunct: 0x2521c30 +19050406470: cap 1: End par conjunction: 0x2521c30 +19050406596: cap 1: End par conjunct: 0x2521bd0 +19050406731: cap 1: End par conjunction: 0x2521bd0 +19050406861: cap 1: End par conjunct: 0x2521b70 +19050406987: cap 1: End par conjunction: 0x2521b70 +19050407113: cap 1: End par conjunct: 0x2521b10 +19050407248: cap 1: End par conjunction: 0x2521b10 +19050407383: cap 1: End par conjunct: 0x2521ab0 +19050407509: cap 1: End par conjunction: 0x2521ab0 +19050407635: cap 1: End par conjunct: 0x2521a50 +19050407761: cap 1: End par conjunction: 0x2521a50 +19050407892: cap 1: End par conjunct: 0x25219f0 +19050408018: cap 1: End par conjunction: 0x25219f0 +19050408148: cap 1: End par conjunct: 0x2521990 +19050408274: cap 1: End par conjunction: 0x2521990 +19050408405: cap 1: End par conjunct: 0x2521930 +19050408535: cap 1: End par conjunction: 0x2521930 +19050408661: cap 1: End par conjunct: 0x25218d0 +19050408792: cap 1: End par conjunction: 0x25218d0 +19050408918: cap 1: End par conjunct: 0x2521870 +19050409053: cap 1: End par conjunction: 0x2521870 +19050409179: cap 1: End par conjunct: 0x2521810 +19050409305: cap 1: End par conjunction: 0x2521810 +19050409440: cap 1: End par conjunct: 0x25217b0 +19050409575: cap 1: End par conjunction: 0x25217b0 +19050409701: cap 1: End par conjunct: 0x2521750 +19050409831: cap 1: End par conjunction: 0x2521750 +19050409962: cap 1: End par conjunct: 0x25216f0 +19050410088: cap 1: End par conjunction: 0x25216f0 +19050410218: cap 1: End par conjunct: 0x2521690 +19050410349: cap 1: End par conjunction: 0x2521690 +19050410488: cap 1: End par conjunct: 0x2521630 +19050410614: cap 1: End par conjunction: 0x2521630 +19050410740: cap 1: End par conjunct: 0x25215d0 +19050410880: cap 1: End par conjunction: 0x25215d0 +19050411051: cap 1: End par conjunct: 0x2521570 +19050411177: cap 1: End par conjunction: 0x2521570 +19050411348: cap 1: End par conjunct: 0x2521510 +19050411483: cap 1: End par conjunction: 0x2521510 +19050411658: cap 1: End par conjunct: 0x25214b0 +19050411784: cap 1: End par conjunction: 0x25214b0 +19050411915: cap 1: End par conjunct: 0x2521450 +19050412045: cap 1: End par conjunction: 0x2521450 +19050412176: cap 1: End par conjunct: 0x25213f0 +19050412302: cap 1: End par conjunction: 0x25213f0 +19050412437: cap 1: End par conjunct: 0x2521390 +19050412563: cap 1: End par conjunction: 0x2521390 +19050412698: cap 1: End par conjunct: 0x2521330 +19050412828: cap 1: End par conjunction: 0x2521330 +19050412959: cap 1: End par conjunct: 0x25212d0 +19050413085: cap 1: End par conjunction: 0x25212d0 +19050413220: cap 1: End par conjunct: 0x2521270 +19050413355: cap 1: End par conjunction: 0x2521270 +19050413481: cap 1: End par conjunct: 0x2521210 +19050413607: cap 1: End par conjunction: 0x2521210 +19050413742: cap 1: End par conjunct: 0x25211b0 +19050413872: cap 1: End par conjunction: 0x25211b0 +19050414003: cap 1: End par conjunct: 0x2521150 +19050414133: cap 1: End par conjunction: 0x2521150 +19050414264: cap 1: End par conjunct: 0x25210f0 +19050414390: cap 1: End par conjunction: 0x25210f0 +19050414520: cap 1: End par conjunct: 0x2521090 +19050414646: cap 1: End par conjunction: 0x2521090 +19050414790: cap 1: End par conjunct: 0x2521030 +19050414912: cap 1: End par conjunction: 0x2521030 +19050415038: cap 1: End par conjunct: 0x2520fd0 +19050415303: cap 1: End par conjunction: 0x2520fd0 +19050415542: cap 1: End par conjunct: 0x2520f70 +19050415785: cap 1: End par conjunction: 0x2520f70 +19050415906: cap 1: End par conjunct: 0x2520f10 +19050416041: cap 1: End par conjunction: 0x2520f10 +19050416176: cap 1: End par conjunct: 0x2520eb0 +19050416302: cap 1: End par conjunction: 0x2520eb0 +19050416428: cap 1: End par conjunct: 0x2520e50 +19050416554: cap 1: End par conjunction: 0x2520e50 +19050416689: cap 1: End par conjunct: 0x2520df0 +19050416811: cap 1: End par conjunction: 0x2520df0 +19050416941: cap 1: End par conjunct: 0x2520d90 +19050417072: cap 1: End par conjunction: 0x2520d90 +19050417202: cap 1: End par conjunct: 0x2520d30 +19050417333: cap 1: End par conjunction: 0x2520d30 +19050417463: cap 1: End par conjunct: 0x2520cd0 +19050417598: cap 1: End par conjunction: 0x2520cd0 +19050417724: cap 1: End par conjunct: 0x2520c70 +19050417864: cap 1: End par conjunction: 0x2520c70 +19050417990: cap 1: End par conjunct: 0x2520c10 +19050418116: cap 1: End par conjunction: 0x2520c10 +19050418246: cap 1: End par conjunct: 0x2520bb0 +19050418377: cap 1: End par conjunction: 0x2520bb0 +19050418512: cap 1: End par conjunct: 0x2520b50 +19050418638: cap 1: End par conjunction: 0x2520b50 +19050418773: cap 1: End par conjunct: 0x2520af0 +19050418894: cap 1: End par conjunction: 0x2520af0 +19050419029: cap 1: End par conjunct: 0x2520a90 +19050419160: cap 1: End par conjunction: 0x2520a90 +19050419295: cap 1: End par conjunct: 0x2520a30 +19050419421: cap 1: End par conjunction: 0x2520a30 +19050419547: cap 1: End par conjunct: 0x25209d0 +19050419686: cap 1: End par conjunction: 0x25209d0 +19050419812: cap 1: End par conjunct: 0x2520970 +19050419938: cap 1: End par conjunction: 0x2520970 +19050420064: cap 1: End par conjunct: 0x2520910 +19050420199: cap 1: End par conjunction: 0x2520910 +19050420334: cap 1: End par conjunct: 0x25208b0 +19050420460: cap 1: End par conjunction: 0x25208b0 +19050420586: cap 1: End par conjunct: 0x2520850 +19050420717: cap 1: End par conjunction: 0x2520850 +19050420847: cap 1: End par conjunct: 0x25207f0 +19050420973: cap 1: End par conjunction: 0x25207f0 +19050421104: cap 1: End par conjunct: 0x2520790 +19050421230: cap 1: End par conjunction: 0x2520790 +19050421360: cap 1: End par conjunct: 0x2520730 +19050421491: cap 1: End par conjunction: 0x2520730 +19050421621: cap 1: End par conjunct: 0x25206d0 +19050421747: cap 1: End par conjunction: 0x25206d0 +19050421873: cap 1: End par conjunct: 0x2520670 +19050422004: cap 1: End par conjunction: 0x2520670 +19050422134: cap 1: End par conjunct: 0x2520610 +19050422260: cap 1: End par conjunction: 0x2520610 +19050422395: cap 1: End par conjunct: 0x25205b0 +19050422530: cap 1: End par conjunction: 0x25205b0 +19050422661: cap 1: End par conjunct: 0x2520550 +19050422787: cap 1: End par conjunction: 0x2520550 +19050422922: cap 1: End par conjunct: 0x25204f0 +19050423048: cap 1: End par conjunction: 0x25204f0 +19050423178: cap 1: End par conjunct: 0x2520490 +19050423309: cap 1: End par conjunction: 0x2520490 +19050423444: cap 1: End par conjunct: 0x2520430 +19050423574: cap 1: End par conjunction: 0x2520430 +19050423696: cap 1: End par conjunct: 0x25203d0 +19050423831: cap 1: End par conjunction: 0x25203d0 +19050423961: cap 1: End par conjunct: 0x2520370 +19050424087: cap 1: End par conjunction: 0x2520370 +19050424213: cap 1: End par conjunct: 0x2520310 +19050424348: cap 1: End par conjunction: 0x2520310 +19050424519: cap 1: End par conjunct: 0x25202b0 +19050424645: cap 1: End par conjunction: 0x25202b0 +19050424771: cap 1: End par conjunct: 0x2520250 +19050424897: cap 1: End par conjunction: 0x2520250 +19050425028: cap 1: End par conjunct: 0x25201f0 +19050425154: cap 1: End par conjunction: 0x25201f0 +19050425284: cap 1: End par conjunct: 0x2520190 +19050425410: cap 1: End par conjunction: 0x2520190 +19050425545: cap 1: End par conjunct: 0x2520130 +19050425676: cap 1: End par conjunction: 0x2520130 +19050425802: cap 1: End par conjunct: 0x25200d0 +19050425928: cap 1: End par conjunction: 0x25200d0 +19050426090: cap 1: End par conjunct: 0x2520070 +19050426225: cap 1: End par conjunction: 0x2520070 +19050426355: cap 1: End par conjunct: 0x2520010 +19050426472: cap 1: End par conjunction: 0x2520010 +19050426828: cap 1: End par conjunct: 0x251ffb0 +19050427093: cap 1: End par conjunction: 0x251ffb0 +19050427224: cap 1: End par conjunct: 0x251ff50 +19050427458: cap 1: End par conjunction: 0x251ff50 +19050427593: cap 1: End par conjunct: 0x251fef0 +19050427719: cap 1: End par conjunction: 0x251fef0 +19050427849: cap 1: End par conjunct: 0x251fe90 +19050427980: cap 1: End par conjunction: 0x251fe90 +19050428115: cap 1: End par conjunct: 0x251fe30 +19050428241: cap 1: End par conjunction: 0x251fe30 +19050428367: cap 1: End par conjunct: 0x251fdd0 +19050428502: cap 1: End par conjunction: 0x251fdd0 +19050428632: cap 1: End par conjunct: 0x251fd70 +19050428763: cap 1: End par conjunction: 0x251fd70 +19050428889: cap 1: End par conjunct: 0x251fd10 +19050429024: cap 1: End par conjunction: 0x251fd10 +19050429159: cap 1: End par conjunct: 0x251fcb0 +19050429280: cap 1: End par conjunction: 0x251fcb0 +19050429406: cap 1: End par conjunct: 0x251fc50 +19050429537: cap 1: End par conjunction: 0x251fc50 +19050429667: cap 1: End par conjunct: 0x251fbf0 +19050429793: cap 1: End par conjunction: 0x251fbf0 +19050429924: cap 1: End par conjunct: 0x251fb90 +19050430050: cap 1: End par conjunction: 0x251fb90 +19050430180: cap 1: End par conjunct: 0x251fb30 +19050430311: cap 1: End par conjunction: 0x251fb30 +19050430437: cap 1: End par conjunct: 0x251fad0 +19050430563: cap 1: End par conjunction: 0x251fad0 +19050430693: cap 1: End par conjunct: 0x251fa70 +19050430824: cap 1: End par conjunction: 0x251fa70 +19050430950: cap 1: End par conjunct: 0x251fa10 +19050431076: cap 1: End par conjunction: 0x251fa10 +19050431211: cap 1: End par conjunct: 0x251f9b0 +19050431346: cap 1: End par conjunction: 0x251f9b0 +19050431476: cap 1: End par conjunct: 0x251f950 +19050431602: cap 1: End par conjunction: 0x251f950 +19050431737: cap 1: End par conjunct: 0x251f8f0 +19050431859: cap 1: End par conjunction: 0x251f8f0 +19050431989: cap 1: End par conjunct: 0x251f890 +19050432120: cap 1: End par conjunction: 0x251f890 +19050432255: cap 1: End par conjunct: 0x251f830 +19050432385: cap 1: End par conjunction: 0x251f830 +19050432507: cap 1: End par conjunct: 0x251f7d0 +19050432646: cap 1: End par conjunction: 0x251f7d0 +19050432772: cap 1: End par conjunct: 0x251f770 +19050432898: cap 1: End par conjunction: 0x251f770 +19050433024: cap 1: End par conjunct: 0x251f710 +19050433159: cap 1: End par conjunction: 0x251f710 +19050433290: cap 1: End par conjunct: 0x251f6b0 +19050433416: cap 1: End par conjunction: 0x251f6b0 +19050433542: cap 1: End par conjunct: 0x251f650 +19050433672: cap 1: End par conjunction: 0x251f650 +19050433803: cap 1: End par conjunct: 0x251f5f0 +19050433929: cap 1: End par conjunction: 0x251f5f0 +19050434059: cap 1: End par conjunct: 0x251f590 +19050434185: cap 1: End par conjunction: 0x251f590 +19050434311: cap 1: End par conjunct: 0x251f530 +19050434442: cap 1: End par conjunction: 0x251f530 +19050434568: cap 1: End par conjunct: 0x251f4d0 +19050434694: cap 1: End par conjunction: 0x251f4d0 +19050434824: cap 1: End par conjunct: 0x251f470 +19050434955: cap 1: End par conjunction: 0x251f470 +19050435085: cap 1: End par conjunct: 0x251f410 +19050435211: cap 1: End par conjunction: 0x251f410 +19050435337: cap 1: End par conjunct: 0x251f3b0 +19050435472: cap 1: End par conjunction: 0x251f3b0 +19050435603: cap 1: End par conjunct: 0x251f350 +19050435729: cap 1: End par conjunction: 0x251f350 +19050435873: cap 1: End par conjunct: 0x251f2f0 +19050435999: cap 1: End par conjunction: 0x251f2f0 +19050436129: cap 1: End par conjunct: 0x251f290 +19050436260: cap 1: End par conjunction: 0x251f290 +19050436507: cap 1: End par conjunct: 0x251f230 +19050436638: cap 1: End par conjunction: 0x251f230 +19050436764: cap 1: End par conjunct: 0x251f1d0 +19050437007: cap 1: End par conjunction: 0x251f1d0 +19050437137: cap 1: End par conjunct: 0x251f170 +19050437268: cap 1: End par conjunction: 0x251f170 +19050437394: cap 1: End par conjunct: 0x251f110 +19050437529: cap 1: End par conjunction: 0x251f110 +19050437659: cap 1: End par conjunct: 0x251f0b0 +19050437893: cap 1: End par conjunction: 0x251f0b0 +19050438024: cap 1: End par conjunct: 0x251f050 +19050438145: cap 1: End par conjunction: 0x251f050 +19050438280: cap 1: End par conjunct: 0x251eff0 +19050438519: cap 1: End par conjunction: 0x251eff0 +19050438649: cap 1: End par conjunct: 0x251ef90 +19050438780: cap 1: End par conjunction: 0x251ef90 +19050438924: cap 1: End par conjunct: 0x251ef30 +19050439054: cap 1: End par conjunction: 0x251ef30 +19050443919: cap 1: End par conjunct: 0x251eed0 +19050444036: cap 1: End par conjunction: 0x251eed0 +19050444171: cap 1: End par conjunct: 0x251ee70 +19050444306: cap 1: End par conjunction: 0x251ee70 +19050444441: cap 1: End par conjunct: 0x251ee10 +19050444562: cap 1: End par conjunction: 0x251ee10 +19050444693: cap 1: End par conjunct: 0x251edb0 +19050444828: cap 1: End par conjunction: 0x251edb0 +19050444963: cap 1: End par conjunct: 0x251ed50 +19050445089: cap 1: End par conjunction: 0x251ed50 +19050445224: cap 1: End par conjunct: 0x251ecf0 +19050445350: cap 1: End par conjunction: 0x251ecf0 +19050445485: cap 1: End par conjunct: 0x251ec90 +19050445611: cap 1: End par conjunction: 0x251ec90 +19050445755: cap 1: End par conjunct: 0x251ec30 +19050445881: cap 1: End par conjunction: 0x251ec30 +19050446007: cap 1: End par conjunct: 0x251ebd0 +19050446142: cap 1: End par conjunction: 0x251ebd0 +19050446272: cap 1: End par conjunct: 0x251eb70 +19050446403: cap 1: End par conjunction: 0x251eb70 +19050446524: cap 1: End par conjunct: 0x251eb10 +19050446659: cap 1: End par conjunction: 0x251eb10 +19050446794: cap 1: End par conjunct: 0x251eab0 +19050446916: cap 1: End par conjunction: 0x251eab0 +19050447042: cap 1: End par conjunct: 0x251ea50 +19050447172: cap 1: End par conjunction: 0x251ea50 +19050447303: cap 1: End par conjunct: 0x251e9f0 +19050447429: cap 1: End par conjunction: 0x251e9f0 +19050447559: cap 1: End par conjunct: 0x251e990 +19050447685: cap 1: End par conjunction: 0x251e990 +19050447820: cap 1: End par conjunct: 0x251e930 +19050447946: cap 1: End par conjunction: 0x251e930 +19050448077: cap 1: End par conjunct: 0x251e8d0 +19050448198: cap 1: End par conjunction: 0x251e8d0 +19050448329: cap 1: End par conjunct: 0x251e870 +19050448464: cap 1: End par conjunction: 0x251e870 +19050448594: cap 1: End par conjunct: 0x251e810 +19050448720: cap 1: End par conjunction: 0x251e810 +19050448851: cap 1: End par conjunct: 0x251e7b0 +19050448986: cap 1: End par conjunction: 0x251e7b0 +19050449116: cap 1: End par conjunct: 0x251e750 +19050449242: cap 1: End par conjunction: 0x251e750 +19050449377: cap 1: End par conjunct: 0x251e6f0 +19050449503: cap 1: End par conjunction: 0x251e6f0 +19050449638: cap 1: End par conjunct: 0x251e690 +19050449764: cap 1: End par conjunction: 0x251e690 +19050449904: cap 1: End par conjunct: 0x251e630 +19050450030: cap 1: End par conjunction: 0x251e630 +19050450156: cap 1: End par conjunct: 0x251e5d0 +19050450295: cap 1: End par conjunction: 0x251e5d0 +19050450426: cap 1: End par conjunct: 0x251e570 +19050450552: cap 1: End par conjunction: 0x251e570 +19050450678: cap 1: End par conjunct: 0x251e510 +19050450813: cap 1: End par conjunction: 0x251e510 +19050450948: cap 1: End par conjunct: 0x251e4b0 +19050451069: cap 1: End par conjunction: 0x251e4b0 +19050451195: cap 1: End par conjunct: 0x251e450 +19050451330: cap 1: End par conjunction: 0x251e450 +19050451461: cap 1: End par conjunct: 0x251e3f0 +19050451587: cap 1: End par conjunction: 0x251e3f0 +19050451717: cap 1: End par conjunct: 0x251e390 +19050451843: cap 1: End par conjunction: 0x251e390 +19050451974: cap 1: End par conjunct: 0x251e330 +19050452104: cap 1: End par conjunction: 0x251e330 +19050452230: cap 1: End par conjunct: 0x251e2d0 +19050452356: cap 1: End par conjunction: 0x251e2d0 +19050452487: cap 1: End par conjunct: 0x251e270 +19050452617: cap 1: End par conjunction: 0x251e270 +19050452748: cap 1: End par conjunct: 0x251e210 +19050452883: cap 1: End par conjunction: 0x251e210 +19050453009: cap 1: End par conjunct: 0x251e1b0 +19050453144: cap 1: End par conjunction: 0x251e1b0 +19050453270: cap 1: End par conjunct: 0x251e150 +19050453396: cap 1: End par conjunction: 0x251e150 +19050453531: cap 1: End par conjunct: 0x251e0f0 +19050453657: cap 1: End par conjunction: 0x251e0f0 +19050453787: cap 1: End par conjunct: 0x251e090 +19050453918: cap 1: End par conjunction: 0x251e090 +19050454048: cap 1: End par conjunct: 0x251e030 +19050454170: cap 1: End par conjunction: 0x251e030 +19050454296: cap 1: End par conjunct: 0x251dfd0 +19050454566: cap 1: End par conjunction: 0x251dfd0 +19050454800: cap 1: End par conjunct: 0x251df70 +19050455052: cap 1: End par conjunction: 0x251df70 +19050455178: cap 1: End par conjunct: 0x251df10 +19050455317: cap 1: End par conjunction: 0x251df10 +19050455448: cap 1: End par conjunct: 0x251deb0 +19050455574: cap 1: End par conjunction: 0x251deb0 +19050455700: cap 1: End par conjunct: 0x251de50 +19050455826: cap 1: End par conjunction: 0x251de50 +19050455956: cap 1: End par conjunct: 0x251ddf0 +19050456082: cap 1: End par conjunction: 0x251ddf0 +19050456213: cap 1: End par conjunct: 0x251dd90 +19050456339: cap 1: End par conjunction: 0x251dd90 +19050456469: cap 1: End par conjunct: 0x251dd30 +19050456600: cap 1: End par conjunction: 0x251dd30 +19050456726: cap 1: End par conjunct: 0x251dcd0 +19050456852: cap 1: End par conjunction: 0x251dcd0 +19050456982: cap 1: End par conjunct: 0x251dc70 +19050457117: cap 1: End par conjunction: 0x251dc70 +19050457248: cap 1: End par conjunct: 0x251dc10 +19050457374: cap 1: End par conjunction: 0x251dc10 +19050457500: cap 1: End par conjunct: 0x251dbb0 +19050457635: cap 1: End par conjunction: 0x251dbb0 +19050457761: cap 1: End par conjunct: 0x251db50 +19050457891: cap 1: End par conjunction: 0x251db50 +19050458022: cap 1: End par conjunct: 0x251daf0 +19050458148: cap 1: End par conjunction: 0x251daf0 +19050458278: cap 1: End par conjunct: 0x251da90 +19050458409: cap 1: End par conjunction: 0x251da90 +19050458539: cap 1: End par conjunct: 0x251da30 +19050458670: cap 1: End par conjunction: 0x251da30 +19050458796: cap 1: End par conjunct: 0x251d9d0 +19050458931: cap 1: End par conjunction: 0x251d9d0 +19050459061: cap 1: End par conjunct: 0x251d970 +19050459192: cap 1: End par conjunction: 0x251d970 +19050459318: cap 1: End par conjunct: 0x251d910 +19050459453: cap 1: End par conjunction: 0x251d910 +19050459579: cap 1: End par conjunct: 0x251d8b0 +19050459709: cap 1: End par conjunction: 0x251d8b0 +19050459835: cap 1: End par conjunct: 0x251d850 +19050459966: cap 1: End par conjunction: 0x251d850 +19050460096: cap 1: End par conjunct: 0x251d7f0 +19050460222: cap 1: End par conjunction: 0x251d7f0 +19050460348: cap 1: End par conjunct: 0x251d790 +19050460474: cap 1: End par conjunction: 0x251d790 +19050460605: cap 1: End par conjunct: 0x251d730 +19050460735: cap 1: End par conjunction: 0x251d730 +19050460866: cap 1: End par conjunct: 0x251d6d0 +19050460987: cap 1: End par conjunction: 0x251d6d0 +19050461118: cap 1: End par conjunct: 0x251d670 +19050461248: cap 1: End par conjunction: 0x251d670 +19050461379: cap 1: End par conjunct: 0x251d610 +19050461509: cap 1: End par conjunction: 0x251d610 +19050461635: cap 1: End par conjunct: 0x251d5b0 +19050461770: cap 1: End par conjunction: 0x251d5b0 +19050461901: cap 1: End par conjunct: 0x251d550 +19050462031: cap 1: End par conjunction: 0x251d550 +19050462162: cap 1: End par conjunct: 0x251d4f0 +19050462288: cap 1: End par conjunction: 0x251d4f0 +19050462418: cap 1: End par conjunct: 0x251d490 +19050462544: cap 1: End par conjunction: 0x251d490 +19050462679: cap 1: End par conjunct: 0x251d430 +19050462805: cap 1: End par conjunction: 0x251d430 +19050462931: cap 1: End par conjunct: 0x251d3d0 +19050463066: cap 1: End par conjunction: 0x251d3d0 +19050463197: cap 1: End par conjunct: 0x251d370 +19050463323: cap 1: End par conjunction: 0x251d370 +19050463453: cap 1: End par conjunct: 0x251d310 +19050463588: cap 1: End par conjunction: 0x251d310 +19050463719: cap 1: End par conjunct: 0x251d2b0 +19050463845: cap 1: End par conjunction: 0x251d2b0 +19050463971: cap 1: End par conjunct: 0x251d250 +19050464101: cap 1: End par conjunction: 0x251d250 +19050464232: cap 1: End par conjunct: 0x251d1f0 +19050464353: cap 1: End par conjunction: 0x251d1f0 +19050464484: cap 1: End par conjunct: 0x251d190 +19050464610: cap 1: End par conjunction: 0x251d190 +19050464740: cap 1: End par conjunct: 0x251d130 +19050464871: cap 1: End par conjunction: 0x251d130 +19050465001: cap 1: End par conjunct: 0x251d0d0 +19050465123: cap 1: End par conjunction: 0x251d0d0 +19050465258: cap 1: End par conjunct: 0x251d070 +19050465388: cap 1: End par conjunction: 0x251d070 +19050465519: cap 1: End par conjunct: 0x251d010 +19050465640: cap 1: End par conjunction: 0x251d010 +19050465883: cap 1: End par conjunct: 0x251cfb0 +19050466297: cap 1: End par conjunction: 0x251cfb0 +19050466423: cap 1: End par conjunct: 0x251cf50 +19050466648: cap 1: End par conjunction: 0x251cf50 +19050466783: cap 1: End par conjunct: 0x251cef0 +19050466909: cap 1: End par conjunction: 0x251cef0 +19050467040: cap 1: End par conjunct: 0x251ce90 +19050467170: cap 1: End par conjunction: 0x251ce90 +19050467305: cap 1: End par conjunct: 0x251ce30 +19050467431: cap 1: End par conjunction: 0x251ce30 +19050467557: cap 1: End par conjunct: 0x251cdd0 +19050467697: cap 1: End par conjunction: 0x251cdd0 +19050467823: cap 1: End par conjunct: 0x251cd70 +19050467953: cap 1: End par conjunction: 0x251cd70 +19050468079: cap 1: End par conjunct: 0x251cd10 +19050468214: cap 1: End par conjunction: 0x251cd10 +19050468345: cap 1: End par conjunct: 0x251ccb0 +19050468471: cap 1: End par conjunction: 0x251ccb0 +19050468597: cap 1: End par conjunct: 0x251cc50 +19050468727: cap 1: End par conjunction: 0x251cc50 +19050468858: cap 1: End par conjunct: 0x251cbf0 +19050468984: cap 1: End par conjunction: 0x251cbf0 +19050469110: cap 1: End par conjunct: 0x251cb90 +19050469236: cap 1: End par conjunction: 0x251cb90 +19050469366: cap 1: End par conjunct: 0x251cb30 +19050469497: cap 1: End par conjunction: 0x251cb30 +19050469623: cap 1: End par conjunct: 0x251cad0 +19050469749: cap 1: End par conjunction: 0x251cad0 +19050469879: cap 1: End par conjunct: 0x251ca70 +19050470014: cap 1: End par conjunction: 0x251ca70 +19050470145: cap 1: End par conjunct: 0x251ca10 +19050470266: cap 1: End par conjunction: 0x251ca10 +19050470397: cap 1: End par conjunct: 0x251c9b0 +19050470532: cap 1: End par conjunction: 0x251c9b0 +19050470662: cap 1: End par conjunct: 0x251c950 +19050470788: cap 1: End par conjunction: 0x251c950 +19050470923: cap 1: End par conjunct: 0x251c8f0 +19050471045: cap 1: End par conjunction: 0x251c8f0 +19050471175: cap 1: End par conjunct: 0x251c890 +19050471306: cap 1: End par conjunction: 0x251c890 +19050471441: cap 1: End par conjunct: 0x251c830 +19050471567: cap 1: End par conjunction: 0x251c830 +19050471693: cap 1: End par conjunct: 0x251c7d0 +19050471945: cap 1: End par conjunction: 0x251c7d0 +19050472075: cap 1: End par conjunct: 0x251c770 +19050472201: cap 1: End par conjunction: 0x251c770 +19050472327: cap 1: End par conjunct: 0x251c710 +19050472566: cap 1: End par conjunction: 0x251c710 +19050472696: cap 1: End par conjunct: 0x251c6b0 +19050472822: cap 1: End par conjunction: 0x251c6b0 +19050472948: cap 1: End par conjunct: 0x251c650 +19050473074: cap 1: End par conjunction: 0x251c650 +19050473205: cap 1: End par conjunct: 0x251c5f0 +19050473331: cap 1: End par conjunction: 0x251c5f0 +19050473461: cap 1: End par conjunct: 0x251c590 +19050473587: cap 1: End par conjunction: 0x251c590 +19050473718: cap 1: End par conjunct: 0x251c530 +19050473848: cap 1: End par conjunction: 0x251c530 +19050473974: cap 1: End par conjunct: 0x251c4d0 +19050474100: cap 1: End par conjunction: 0x251c4d0 +19050474231: cap 1: End par conjunct: 0x251c470 +19050474361: cap 1: End par conjunction: 0x251c470 +19050474492: cap 1: End par conjunct: 0x251c410 +19050474618: cap 1: End par conjunction: 0x251c410 +19050474748: cap 1: End par conjunct: 0x251c3b0 +19050474879: cap 1: End par conjunction: 0x251c3b0 +19050475009: cap 1: End par conjunct: 0x251c350 +19050475135: cap 1: End par conjunction: 0x251c350 +19050475270: cap 1: End par conjunct: 0x251c2f0 +19050475396: cap 1: End par conjunction: 0x251c2f0 +19050475527: cap 1: End par conjunct: 0x251c290 +19050475657: cap 1: End par conjunction: 0x251c290 +19050475788: cap 1: End par conjunct: 0x251c230 +19050475914: cap 1: End par conjunction: 0x251c230 +19050476040: cap 1: End par conjunct: 0x251c1d0 +19050476179: cap 1: End par conjunction: 0x251c1d0 +19050476305: cap 1: End par conjunct: 0x251c170 +19050476436: cap 1: End par conjunction: 0x251c170 +19050476557: cap 1: End par conjunct: 0x251c110 +19050476692: cap 1: End par conjunction: 0x251c110 +19050476823: cap 1: End par conjunct: 0x251c0b0 +19050477061: cap 1: End par conjunction: 0x251c0b0 +19050477187: cap 1: End par conjunct: 0x251c050 +19050477313: cap 1: End par conjunction: 0x251c050 +19050477444: cap 1: End par conjunct: 0x251bff0 +19050477678: cap 1: End par conjunction: 0x251bff0 +19050477808: cap 1: End par conjunct: 0x251bf90 +19050477934: cap 1: End par conjunction: 0x251bf90 +19050478069: cap 1: End par conjunct: 0x251bf30 +19050478200: cap 1: End par conjunction: 0x251bf30 +19050478326: cap 1: End par conjunct: 0x251bed0 +19050478452: cap 1: End par conjunction: 0x251bed0 +19050478582: cap 1: End par conjunct: 0x251be70 +19050478713: cap 1: End par conjunction: 0x251be70 +19050478843: cap 1: End par conjunct: 0x251be10 +19050478969: cap 1: End par conjunction: 0x251be10 +19050479095: cap 1: End par conjunct: 0x251bdb0 +19050479230: cap 1: End par conjunction: 0x251bdb0 +19050479361: cap 1: End par conjunct: 0x251bd50 +19050479487: cap 1: End par conjunction: 0x251bd50 +19050479622: cap 1: End par conjunct: 0x251bcf0 +19050479748: cap 1: End par conjunction: 0x251bcf0 +19050479878: cap 1: End par conjunct: 0x251bc90 +19050480009: cap 1: End par conjunction: 0x251bc90 +19050480144: cap 1: End par conjunct: 0x251bc30 +19050480270: cap 1: End par conjunction: 0x251bc30 +19050480396: cap 1: End par conjunct: 0x251bbd0 +19050480531: cap 1: End par conjunction: 0x251bbd0 +19050480657: cap 1: End par conjunct: 0x251bb70 +19050480783: cap 1: End par conjunction: 0x251bb70 +19050480909: cap 1: End par conjunct: 0x251bb10 +19050481048: cap 1: End par conjunction: 0x251bb10 +19050481174: cap 1: End par conjunct: 0x251bab0 +19050481300: cap 1: End par conjunction: 0x251bab0 +19050481426: cap 1: End par conjunct: 0x251ba50 +19050481557: cap 1: End par conjunction: 0x251ba50 +19050481687: cap 1: End par conjunct: 0x251b9f0 +19050481813: cap 1: End par conjunction: 0x251b9f0 +19050481944: cap 1: End par conjunct: 0x251b990 +19050482065: cap 1: End par conjunction: 0x251b990 +19050482196: cap 1: End par conjunct: 0x251b930 +19050482326: cap 1: End par conjunction: 0x251b930 +19050482452: cap 1: End par conjunct: 0x251b8d0 +19050482578: cap 1: End par conjunction: 0x251b8d0 +19050482709: cap 1: End par conjunct: 0x251b870 +19050482844: cap 1: End par conjunction: 0x251b870 +19050482974: cap 1: End par conjunct: 0x251b810 +19050483100: cap 1: End par conjunction: 0x251b810 +19050483226: cap 1: End par conjunct: 0x251b7b0 +19050483357: cap 1: End par conjunction: 0x251b7b0 +19050483487: cap 1: End par conjunct: 0x251b750 +19050483618: cap 1: End par conjunction: 0x251b750 +19050483748: cap 1: End par conjunct: 0x251b6f0 +19050483874: cap 1: End par conjunction: 0x251b6f0 +19050484005: cap 1: End par conjunct: 0x251b690 +19050484135: cap 1: End par conjunction: 0x251b690 +19050484311: cap 1: End par conjunct: 0x251b630 +19050484441: cap 1: End par conjunction: 0x251b630 +19050484567: cap 1: End par conjunct: 0x251b5d0 +19050484702: cap 1: End par conjunction: 0x251b5d0 +19050484869: cap 1: End par conjunct: 0x251b570 +19050484999: cap 1: End par conjunction: 0x251b570 +19050485166: cap 1: End par conjunct: 0x251b510 +19050485301: cap 1: End par conjunction: 0x251b510 +19050485467: cap 1: End par conjunct: 0x251b4b0 +19050485593: cap 1: End par conjunction: 0x251b4b0 +19050485724: cap 1: End par conjunct: 0x251b450 +19050485854: cap 1: End par conjunction: 0x251b450 +19050485989: cap 1: End par conjunct: 0x251b3f0 +19050486115: cap 1: End par conjunction: 0x251b3f0 +19050486246: cap 1: End par conjunct: 0x251b390 +19050486372: cap 1: End par conjunction: 0x251b390 +19050486507: cap 1: End par conjunct: 0x251b330 +19050486637: cap 1: End par conjunction: 0x251b330 +19050486768: cap 1: End par conjunct: 0x251b2d0 +19050486894: cap 1: End par conjunction: 0x251b2d0 +19050487029: cap 1: End par conjunct: 0x251b270 +19050487159: cap 1: End par conjunction: 0x251b270 +19050487294: cap 1: End par conjunct: 0x251b210 +19050487420: cap 1: End par conjunction: 0x251b210 +19050487551: cap 1: End par conjunct: 0x251b1b0 +19050487686: cap 1: End par conjunction: 0x251b1b0 +19050487816: cap 1: End par conjunct: 0x251b150 +19050487947: cap 1: End par conjunction: 0x251b150 +19050488082: cap 1: End par conjunct: 0x251b0f0 +19050488208: cap 1: End par conjunction: 0x251b0f0 +19050488338: cap 1: End par conjunct: 0x251b090 +19050488469: cap 1: End par conjunction: 0x251b090 +19050488604: cap 1: End par conjunct: 0x251b030 +19050488725: cap 1: End par conjunction: 0x251b030 +19050488856: cap 1: End par conjunct: 0x251afd0 +19050489112: cap 1: End par conjunction: 0x251afd0 +19050489355: cap 1: End par conjunct: 0x251af70 +19050489598: cap 1: End par conjunction: 0x251af70 +19050489724: cap 1: End par conjunct: 0x251af10 +19050489859: cap 1: End par conjunction: 0x251af10 +19050489985: cap 1: End par conjunct: 0x251aeb0 +19050490111: cap 1: End par conjunction: 0x251aeb0 +19050490237: cap 1: End par conjunct: 0x251ae50 +19050490368: cap 1: End par conjunction: 0x251ae50 +19050490494: cap 1: End par conjunct: 0x251adf0 +19050490620: cap 1: End par conjunction: 0x251adf0 +19050490750: cap 1: End par conjunct: 0x251ad90 +19050490876: cap 1: End par conjunction: 0x251ad90 +19050491007: cap 1: End par conjunct: 0x251ad30 +19050491133: cap 1: End par conjunction: 0x251ad30 +19050491263: cap 1: End par conjunct: 0x251acd0 +19050491389: cap 1: End par conjunction: 0x251acd0 +19050491520: cap 1: End par conjunct: 0x251ac70 +19050491650: cap 1: End par conjunction: 0x251ac70 +19050491781: cap 1: End par conjunct: 0x251ac10 +19050491907: cap 1: End par conjunction: 0x251ac10 +19050492033: cap 1: End par conjunct: 0x251abb0 +19050492163: cap 1: End par conjunction: 0x251abb0 +19050492298: cap 1: End par conjunct: 0x251ab50 +19050492424: cap 1: End par conjunction: 0x251ab50 +19050492559: cap 1: End par conjunct: 0x251aaf0 +19050492685: cap 1: End par conjunction: 0x251aaf0 +19050492820: cap 1: End par conjunct: 0x251aa90 +19050492951: cap 1: End par conjunction: 0x251aa90 +19050493086: cap 1: End par conjunct: 0x251aa30 +19050493216: cap 1: End par conjunction: 0x251aa30 +19050493342: cap 1: End par conjunct: 0x251a9d0 +19050493477: cap 1: End par conjunction: 0x251a9d0 +19050493608: cap 1: End par conjunct: 0x251a970 +19050493734: cap 1: End par conjunction: 0x251a970 +19050493864: cap 1: End par conjunct: 0x251a910 +19050493999: cap 1: End par conjunction: 0x251a910 +19050494130: cap 1: End par conjunct: 0x251a8b0 +19050494256: cap 1: End par conjunction: 0x251a8b0 +19050494382: cap 1: End par conjunct: 0x251a850 +19050494512: cap 1: End par conjunction: 0x251a850 +19050494643: cap 1: End par conjunct: 0x251a7f0 +19050494769: cap 1: End par conjunction: 0x251a7f0 +19050494899: cap 1: End par conjunct: 0x251a790 +19050495025: cap 1: End par conjunction: 0x251a790 +19050495151: cap 1: End par conjunct: 0x251a730 +19050495282: cap 1: End par conjunction: 0x251a730 +19050495412: cap 1: End par conjunct: 0x251a6d0 +19050495538: cap 1: End par conjunction: 0x251a6d0 +19050495664: cap 1: End par conjunct: 0x251a670 +19050495795: cap 1: End par conjunction: 0x251a670 +19050495925: cap 1: End par conjunct: 0x251a610 +19050496051: cap 1: End par conjunction: 0x251a610 +19050496182: cap 1: End par conjunct: 0x251a5b0 +19050496317: cap 1: End par conjunction: 0x251a5b0 +19050496452: cap 1: End par conjunct: 0x251a550 +19050496578: cap 1: End par conjunction: 0x251a550 +19050496713: cap 1: End par conjunct: 0x251a4f0 +19050496839: cap 1: End par conjunction: 0x251a4f0 +19050496974: cap 1: End par conjunct: 0x251a490 +19050497100: cap 1: End par conjunction: 0x251a490 +19050497235: cap 1: End par conjunct: 0x251a430 +19050497361: cap 1: End par conjunction: 0x251a430 +19050497491: cap 1: End par conjunct: 0x251a3d0 +19050497626: cap 1: End par conjunction: 0x251a3d0 +19050497752: cap 1: End par conjunct: 0x251a370 +19050497883: cap 1: End par conjunction: 0x251a370 +19050498009: cap 1: End par conjunct: 0x251a310 +19050498144: cap 1: End par conjunction: 0x251a310 +19050498319: cap 1: End par conjunct: 0x251a2b0 +19050498441: cap 1: End par conjunction: 0x251a2b0 +19050498571: cap 1: End par conjunct: 0x251a250 +19050498697: cap 1: End par conjunction: 0x251a250 +19050498832: cap 1: End par conjunct: 0x251a1f0 +19050498958: cap 1: End par conjunction: 0x251a1f0 +19050499089: cap 1: End par conjunct: 0x251a190 +19050499210: cap 1: End par conjunction: 0x251a190 +19050499345: cap 1: End par conjunct: 0x251a130 +19050499471: cap 1: End par conjunction: 0x251a130 +19050499602: cap 1: End par conjunct: 0x251a0d0 +19050499728: cap 1: End par conjunction: 0x251a0d0 +19050499863: cap 1: End par conjunct: 0x251a070 +19050499993: cap 1: End par conjunction: 0x251a070 +19050500124: cap 1: End par conjunct: 0x251a010 +19050500245: cap 1: End par conjunction: 0x251a010 +19050500493: cap 1: End par conjunct: 0x2519fb0 +19050500740: cap 1: End par conjunction: 0x2519fb0 +19050500871: cap 1: End par conjunct: 0x2519f50 +19050501078: cap 1: End par conjunction: 0x2519f50 +19050501213: cap 1: End par conjunct: 0x2519ef0 +19050501334: cap 1: End par conjunction: 0x2519ef0 +19050501469: cap 1: End par conjunct: 0x2519e90 +19050501595: cap 1: End par conjunction: 0x2519e90 +19050501735: cap 1: End par conjunct: 0x2519e30 +19050501865: cap 1: End par conjunction: 0x2519e30 +19050501991: cap 1: End par conjunct: 0x2519dd0 +19050502126: cap 1: End par conjunction: 0x2519dd0 +19050502257: cap 1: End par conjunct: 0x2519d70 +19050502383: cap 1: End par conjunction: 0x2519d70 +19050502513: cap 1: End par conjunct: 0x2519d10 +19050502752: cap 1: End par conjunction: 0x2519d10 +19050502882: cap 1: End par conjunct: 0x2519cb0 +19050503008: cap 1: End par conjunction: 0x2519cb0 +19050503134: cap 1: End par conjunct: 0x2519c50 +19050503368: cap 1: End par conjunction: 0x2519c50 +19050503503: cap 1: End par conjunct: 0x2519bf0 +19050503629: cap 1: End par conjunction: 0x2519bf0 +19050503760: cap 1: End par conjunct: 0x2519b90 +19050503881: cap 1: End par conjunction: 0x2519b90 +19050504007: cap 1: End par conjunct: 0x2519b30 +19050504138: cap 1: End par conjunction: 0x2519b30 +19050504268: cap 1: End par conjunct: 0x2519ad0 +19050504390: cap 1: End par conjunction: 0x2519ad0 +19050504520: cap 1: End par conjunct: 0x2519a70 +19050504651: cap 1: End par conjunction: 0x2519a70 +19050504781: cap 1: End par conjunct: 0x2519a10 +19050504907: cap 1: End par conjunction: 0x2519a10 +19050505033: cap 1: End par conjunct: 0x25199b0 +19050505168: cap 1: End par conjunction: 0x25199b0 +19050505299: cap 1: End par conjunct: 0x2519950 +19050505429: cap 1: End par conjunction: 0x2519950 +19050505560: cap 1: End par conjunct: 0x25198f0 +19050505686: cap 1: End par conjunction: 0x25198f0 +19050505816: cap 1: End par conjunct: 0x2519890 +19050505947: cap 1: End par conjunction: 0x2519890 +19050506082: cap 1: End par conjunct: 0x2519830 +19050506208: cap 1: End par conjunction: 0x2519830 +19050506338: cap 1: End par conjunct: 0x25197d0 +19050506469: cap 1: End par conjunction: 0x25197d0 +19050506599: cap 1: End par conjunct: 0x2519770 +19050506725: cap 1: End par conjunction: 0x2519770 +19050506851: cap 1: End par conjunct: 0x2519710 +19050506986: cap 1: End par conjunction: 0x2519710 +19050507117: cap 1: End par conjunct: 0x25196b0 +19050507238: cap 1: End par conjunction: 0x25196b0 +19050507369: cap 1: End par conjunct: 0x2519650 +19050507495: cap 1: End par conjunction: 0x2519650 +19050507625: cap 1: End par conjunct: 0x25195f0 +19050507751: cap 1: End par conjunction: 0x25195f0 +19050507882: cap 1: End par conjunct: 0x2519590 +19050508003: cap 1: End par conjunction: 0x2519590 +19050508134: cap 1: End par conjunct: 0x2519530 +19050508264: cap 1: End par conjunction: 0x2519530 +19050508390: cap 1: End par conjunct: 0x25194d0 +19050508516: cap 1: End par conjunction: 0x25194d0 +19050508647: cap 1: End par conjunct: 0x2519470 +19050508782: cap 1: End par conjunction: 0x2519470 +19050508908: cap 1: End par conjunct: 0x2519410 +19050509034: cap 1: End par conjunction: 0x2519410 +19050509169: cap 1: End par conjunct: 0x25193b0 +19050509299: cap 1: End par conjunction: 0x25193b0 +19050509434: cap 1: End par conjunct: 0x2519350 +19050509560: cap 1: End par conjunction: 0x2519350 +19050509704: cap 1: End par conjunct: 0x25192f0 +19050509830: cap 1: End par conjunction: 0x25192f0 +19050509961: cap 1: End par conjunct: 0x2519290 +19050510091: cap 1: End par conjunction: 0x2519290 +19050510226: cap 1: End par conjunct: 0x2519230 +19050510352: cap 1: End par conjunction: 0x2519230 +19050510478: cap 1: End par conjunct: 0x25191d0 +19050510613: cap 1: End par conjunction: 0x25191d0 +19050510739: cap 1: End par conjunct: 0x2519170 +19050510870: cap 1: End par conjunction: 0x2519170 +19050510996: cap 1: End par conjunct: 0x2519110 +19050511131: cap 1: End par conjunction: 0x2519110 +19050511261: cap 1: End par conjunct: 0x25190b0 +19050511495: cap 1: End par conjunction: 0x25190b0 +19050511626: cap 1: End par conjunct: 0x2519050 +19050511747: cap 1: End par conjunction: 0x2519050 +19050511878: cap 1: End par conjunct: 0x2518ff0 +19050512121: cap 1: End par conjunction: 0x2518ff0 +19050512251: cap 1: End par conjunct: 0x2518f90 +19050512382: cap 1: End par conjunction: 0x2518f90 +19050512526: cap 1: End par conjunct: 0x2518f30 +19050512652: cap 1: End par conjunction: 0x2518f30 +19050517093: cap 1: End par conjunct: 0x2518ed0 +19050517215: cap 1: End par conjunction: 0x2518ed0 +19050517345: cap 1: End par conjunct: 0x2518e70 +19050517485: cap 1: End par conjunction: 0x2518e70 +19050517615: cap 1: End par conjunct: 0x2518e10 +19050517741: cap 1: End par conjunction: 0x2518e10 +19050517867: cap 1: End par conjunct: 0x2518db0 +19050518002: cap 1: End par conjunction: 0x2518db0 +19050518133: cap 1: End par conjunct: 0x2518d50 +19050518259: cap 1: End par conjunction: 0x2518d50 +19050518394: cap 1: End par conjunct: 0x2518cf0 +19050518520: cap 1: End par conjunction: 0x2518cf0 +19050518650: cap 1: End par conjunct: 0x2518c90 +19050518781: cap 1: End par conjunction: 0x2518c90 +19050518911: cap 1: End par conjunct: 0x2518c30 +19050519037: cap 1: End par conjunction: 0x2518c30 +19050519163: cap 1: End par conjunct: 0x2518bd0 +19050519298: cap 1: End par conjunction: 0x2518bd0 +19050519429: cap 1: End par conjunct: 0x2518b70 +19050519559: cap 1: End par conjunction: 0x2518b70 +19050519681: cap 1: End par conjunct: 0x2518b10 +19050519816: cap 1: End par conjunction: 0x2518b10 +19050519942: cap 1: End par conjunct: 0x2518ab0 +19050520068: cap 1: End par conjunction: 0x2518ab0 +19050520194: cap 1: End par conjunct: 0x2518a50 +19050520324: cap 1: End par conjunction: 0x2518a50 +19050520455: cap 1: End par conjunct: 0x25189f0 +19050520581: cap 1: End par conjunction: 0x25189f0 +19050520711: cap 1: End par conjunct: 0x2518990 +19050520837: cap 1: End par conjunction: 0x2518990 +19050520963: cap 1: End par conjunct: 0x2518930 +19050521089: cap 1: End par conjunction: 0x2518930 +19050521220: cap 1: End par conjunct: 0x25188d0 +19050521341: cap 1: End par conjunction: 0x25188d0 +19050521472: cap 1: End par conjunct: 0x2518870 +19050521607: cap 1: End par conjunction: 0x2518870 +19050521737: cap 1: End par conjunct: 0x2518810 +19050521863: cap 1: End par conjunction: 0x2518810 +19050521989: cap 1: End par conjunct: 0x25187b0 +19050522124: cap 1: End par conjunction: 0x25187b0 +19050522255: cap 1: End par conjunct: 0x2518750 +19050522381: cap 1: End par conjunction: 0x2518750 +19050522516: cap 1: End par conjunct: 0x25186f0 +19050522642: cap 1: End par conjunction: 0x25186f0 +19050522772: cap 1: End par conjunct: 0x2518690 +19050522903: cap 1: End par conjunction: 0x2518690 +19050523038: cap 1: End par conjunct: 0x2518630 +19050523164: cap 1: End par conjunction: 0x2518630 +19050523290: cap 1: End par conjunct: 0x25185d0 +19050523429: cap 1: End par conjunction: 0x25185d0 +19050523555: cap 1: End par conjunct: 0x2518570 +19050523686: cap 1: End par conjunction: 0x2518570 +19050523812: cap 1: End par conjunct: 0x2518510 +19050523947: cap 1: End par conjunction: 0x2518510 +19050524073: cap 1: End par conjunct: 0x25184b0 +19050524199: cap 1: End par conjunction: 0x25184b0 +19050524325: cap 1: End par conjunct: 0x2518450 +19050524455: cap 1: End par conjunction: 0x2518450 +19050524586: cap 1: End par conjunct: 0x25183f0 +19050524712: cap 1: End par conjunction: 0x25183f0 +19050524842: cap 1: End par conjunct: 0x2518390 +19050524968: cap 1: End par conjunction: 0x2518390 +19050525094: cap 1: End par conjunct: 0x2518330 +19050525220: cap 1: End par conjunction: 0x2518330 +19050525346: cap 1: End par conjunct: 0x25182d0 +19050525472: cap 1: End par conjunction: 0x25182d0 +19050525603: cap 1: End par conjunct: 0x2518270 +19050525733: cap 1: End par conjunction: 0x2518270 +19050525868: cap 1: End par conjunct: 0x2518210 +19050525994: cap 1: End par conjunction: 0x2518210 +19050526120: cap 1: End par conjunct: 0x25181b0 +19050526255: cap 1: End par conjunction: 0x25181b0 +19050526381: cap 1: End par conjunct: 0x2518150 +19050526512: cap 1: End par conjunction: 0x2518150 +19050526647: cap 1: End par conjunct: 0x25180f0 +19050526773: cap 1: End par conjunction: 0x25180f0 +19050526899: cap 1: End par conjunct: 0x2518090 +19050527029: cap 1: End par conjunction: 0x2518090 +19050527164: cap 1: End par conjunct: 0x2518030 +19050527281: cap 1: End par conjunction: 0x2518030 +19050527407: cap 1: End par conjunct: 0x2517fd0 +19050527682: cap 1: End par conjunction: 0x2517fd0 +19050527925: cap 1: End par conjunct: 0x2517f70 +19050528172: cap 1: End par conjunction: 0x2517f70 +19050528298: cap 1: End par conjunct: 0x2517f10 +19050528433: cap 1: End par conjunction: 0x2517f10 +19050528564: cap 1: End par conjunct: 0x2517eb0 +19050528690: cap 1: End par conjunction: 0x2517eb0 +19050528816: cap 1: End par conjunct: 0x2517e50 +19050528942: cap 1: End par conjunction: 0x2517e50 +19050529077: cap 1: End par conjunct: 0x2517df0 +19050529203: cap 1: End par conjunction: 0x2517df0 +19050529333: cap 1: End par conjunct: 0x2517d90 +19050529459: cap 1: End par conjunction: 0x2517d90 +19050529590: cap 1: End par conjunct: 0x2517d30 +19050529720: cap 1: End par conjunction: 0x2517d30 +19050529846: cap 1: End par conjunct: 0x2517cd0 +19050529972: cap 1: End par conjunction: 0x2517cd0 +19050530103: cap 1: End par conjunct: 0x2517c70 +19050530238: cap 1: End par conjunction: 0x2517c70 +19050530373: cap 1: End par conjunct: 0x2517c10 +19050530494: cap 1: End par conjunction: 0x2517c10 +19050530625: cap 1: End par conjunct: 0x2517bb0 +19050530755: cap 1: End par conjunction: 0x2517bb0 +19050530886: cap 1: End par conjunct: 0x2517b50 +19050531016: cap 1: End par conjunction: 0x2517b50 +19050531147: cap 1: End par conjunct: 0x2517af0 +19050531273: cap 1: End par conjunction: 0x2517af0 +19050531403: cap 1: End par conjunct: 0x2517a90 +19050531534: cap 1: End par conjunction: 0x2517a90 +19050531669: cap 1: End par conjunct: 0x2517a30 +19050531795: cap 1: End par conjunction: 0x2517a30 +19050531921: cap 1: End par conjunct: 0x25179d0 +19050532060: cap 1: End par conjunction: 0x25179d0 +19050532186: cap 1: End par conjunct: 0x2517970 +19050532317: cap 1: End par conjunction: 0x2517970 +19050532443: cap 1: End par conjunct: 0x2517910 +19050532578: cap 1: End par conjunction: 0x2517910 +19050532704: cap 1: End par conjunct: 0x25178b0 +19050532830: cap 1: End par conjunction: 0x25178b0 +19050532956: cap 1: End par conjunct: 0x2517850 +19050533086: cap 1: End par conjunction: 0x2517850 +19050533221: cap 1: End par conjunct: 0x25177f0 +19050533343: cap 1: End par conjunction: 0x25177f0 +19050533473: cap 1: End par conjunct: 0x2517790 +19050533599: cap 1: End par conjunction: 0x2517790 +19050533730: cap 1: End par conjunct: 0x2517730 +19050533860: cap 1: End par conjunction: 0x2517730 +19050533991: cap 1: End par conjunct: 0x25176d0 +19050534117: cap 1: End par conjunction: 0x25176d0 +19050534247: cap 1: End par conjunct: 0x2517670 +19050534378: cap 1: End par conjunction: 0x2517670 +19050534513: cap 1: End par conjunct: 0x2517610 +19050534634: cap 1: End par conjunction: 0x2517610 +19050534765: cap 1: End par conjunct: 0x25175b0 +19050534900: cap 1: End par conjunction: 0x25175b0 +19050535030: cap 1: End par conjunct: 0x2517550 +19050535156: cap 1: End par conjunction: 0x2517550 +19050535291: cap 1: End par conjunct: 0x25174f0 +19050535417: cap 1: End par conjunction: 0x25174f0 +19050535548: cap 1: End par conjunct: 0x2517490 +19050535678: cap 1: End par conjunction: 0x2517490 +19050535809: cap 1: End par conjunct: 0x2517430 +19050535939: cap 1: End par conjunction: 0x2517430 +19050536065: cap 1: End par conjunct: 0x25173d0 +19050536200: cap 1: End par conjunction: 0x25173d0 +19050536326: cap 1: End par conjunct: 0x2517370 +19050536457: cap 1: End par conjunction: 0x2517370 +19050536583: cap 1: End par conjunct: 0x2517310 +19050536722: cap 1: End par conjunction: 0x2517310 +19050536848: cap 1: End par conjunct: 0x25172b0 +19050536974: cap 1: End par conjunction: 0x25172b0 +19050537100: cap 1: End par conjunct: 0x2517250 +19050537343: cap 1: End par conjunction: 0x2517250 +19050537474: cap 1: End par conjunct: 0x25171f0 +19050537600: cap 1: End par conjunction: 0x25171f0 +19050537843: cap 1: End par conjunct: 0x2517190 +19050537969: cap 1: End par conjunction: 0x2517190 +19050538104: cap 1: End par conjunct: 0x2517130 +19050538234: cap 1: End par conjunction: 0x2517130 +19050538360: cap 1: End par conjunct: 0x25170d0 +19050538486: cap 1: End par conjunction: 0x25170d0 +19050538621: cap 1: End par conjunct: 0x2517070 +19050538752: cap 1: End par conjunction: 0x2517070 +19050538882: cap 1: End par conjunct: 0x2517010 +19050539004: cap 1: End par conjunction: 0x2517010 +19050539247: cap 1: End par conjunct: 0x2516fb0 +19050539521: cap 1: End par conjunction: 0x2516fb0 +19050539652: cap 1: End par conjunct: 0x2516f50 +19050539859: cap 1: End par conjunction: 0x2516f50 +19050539994: cap 1: End par conjunct: 0x2516ef0 +19050540120: cap 1: End par conjunction: 0x2516ef0 +19050540250: cap 1: End par conjunct: 0x2516e90 +19050540381: cap 1: End par conjunction: 0x2516e90 +19050540511: cap 1: End par conjunct: 0x2516e30 +19050540642: cap 1: End par conjunction: 0x2516e30 +19050540768: cap 1: End par conjunct: 0x2516dd0 +19050540903: cap 1: End par conjunction: 0x2516dd0 +19050541029: cap 1: End par conjunct: 0x2516d70 +19050541159: cap 1: End par conjunction: 0x2516d70 +19050541285: cap 1: End par conjunct: 0x2516d10 +19050541420: cap 1: End par conjunction: 0x2516d10 +19050541546: cap 1: End par conjunct: 0x2516cb0 +19050541672: cap 1: End par conjunction: 0x2516cb0 +19050541798: cap 1: End par conjunct: 0x2516c50 +19050541929: cap 1: End par conjunction: 0x2516c50 +19050542059: cap 1: End par conjunct: 0x2516bf0 +19050542185: cap 1: End par conjunction: 0x2516bf0 +19050542316: cap 1: End par conjunct: 0x2516b90 +19050542442: cap 1: End par conjunction: 0x2516b90 +19050542572: cap 1: End par conjunct: 0x2516b30 +19050542703: cap 1: End par conjunction: 0x2516b30 +19050542829: cap 1: End par conjunct: 0x2516ad0 +19050542955: cap 1: End par conjunction: 0x2516ad0 +19050543085: cap 1: End par conjunct: 0x2516a70 +19050543216: cap 1: End par conjunction: 0x2516a70 +19050543351: cap 1: End par conjunct: 0x2516a10 +19050543472: cap 1: End par conjunction: 0x2516a10 +19050543603: cap 1: End par conjunct: 0x25169b0 +19050543738: cap 1: End par conjunction: 0x25169b0 +19050543868: cap 1: End par conjunct: 0x2516950 +19050543994: cap 1: End par conjunction: 0x2516950 +19050544129: cap 1: End par conjunct: 0x25168f0 +19050544251: cap 1: End par conjunction: 0x25168f0 +19050544386: cap 1: End par conjunct: 0x2516890 +19050544516: cap 1: End par conjunction: 0x2516890 +19050544647: cap 1: End par conjunct: 0x2516830 +19050544777: cap 1: End par conjunction: 0x2516830 +19050544903: cap 1: End par conjunct: 0x25167d0 +19050545038: cap 1: End par conjunction: 0x25167d0 +19050545164: cap 1: End par conjunct: 0x2516770 +19050545295: cap 1: End par conjunction: 0x2516770 +19050545421: cap 1: End par conjunct: 0x2516710 +19050545556: cap 1: End par conjunction: 0x2516710 +19050545686: cap 1: End par conjunct: 0x25166b0 +19050545812: cap 1: End par conjunction: 0x25166b0 +19050545938: cap 1: End par conjunct: 0x2516650 +19050546069: cap 1: End par conjunction: 0x2516650 +19050546199: cap 1: End par conjunct: 0x25165f0 +19050546321: cap 1: End par conjunction: 0x25165f0 +19050546451: cap 1: End par conjunct: 0x2516590 +19050546577: cap 1: End par conjunction: 0x2516590 +19050546708: cap 1: End par conjunct: 0x2516530 +19050546838: cap 1: End par conjunction: 0x2516530 +19050546969: cap 1: End par conjunct: 0x25164d0 +19050547090: cap 1: End par conjunction: 0x25164d0 +19050547221: cap 1: End par conjunct: 0x2516470 +19050547356: cap 1: End par conjunction: 0x2516470 +19050547486: cap 1: End par conjunct: 0x2516410 +19050547612: cap 1: End par conjunction: 0x2516410 +19050547738: cap 1: End par conjunct: 0x25163b0 +19050547873: cap 1: End par conjunction: 0x25163b0 +19050548004: cap 1: End par conjunct: 0x2516350 +19050548130: cap 1: End par conjunction: 0x2516350 +19050548265: cap 1: End par conjunct: 0x25162f0 +19050548391: cap 1: End par conjunction: 0x25162f0 +19050548521: cap 1: End par conjunct: 0x2516290 +19050548652: cap 1: End par conjunction: 0x2516290 +19050548787: cap 1: End par conjunct: 0x2516230 +19050548917: cap 1: End par conjunction: 0x2516230 +19050549043: cap 1: End par conjunct: 0x25161d0 +19050549178: cap 1: End par conjunction: 0x25161d0 +19050549313: cap 1: End par conjunct: 0x2516170 +19050549439: cap 1: End par conjunction: 0x2516170 +19050549570: cap 1: End par conjunct: 0x2516110 +19050549705: cap 1: End par conjunction: 0x2516110 +19050549840: cap 1: End par conjunct: 0x25160b0 +19050550074: cap 1: End par conjunction: 0x25160b0 +19050550200: cap 1: End par conjunct: 0x2516050 +19050550326: cap 1: End par conjunction: 0x2516050 +19050550461: cap 1: End par conjunct: 0x2515ff0 +19050550699: cap 1: End par conjunction: 0x2515ff0 +19050550830: cap 1: End par conjunct: 0x2515f90 +19050550956: cap 1: End par conjunction: 0x2515f90 +19050551095: cap 1: End par conjunct: 0x2515f30 +19050551226: cap 1: End par conjunction: 0x2515f30 +19050551352: cap 1: End par conjunct: 0x2515ed0 +19050551478: cap 1: End par conjunction: 0x2515ed0 +19050551613: cap 1: End par conjunct: 0x2515e70 +19050551743: cap 1: End par conjunction: 0x2515e70 +19050551874: cap 1: End par conjunct: 0x2515e10 +19050552000: cap 1: End par conjunction: 0x2515e10 +19050552135: cap 1: End par conjunct: 0x2515db0 +19050552270: cap 1: End par conjunction: 0x2515db0 +19050552400: cap 1: End par conjunct: 0x2515d50 +19050552526: cap 1: End par conjunction: 0x2515d50 +19050552661: cap 1: End par conjunct: 0x2515cf0 +19050552787: cap 1: End par conjunction: 0x2515cf0 +19050552918: cap 1: End par conjunct: 0x2515c90 +19050553048: cap 1: End par conjunction: 0x2515c90 +19050553192: cap 1: End par conjunct: 0x2515c30 +19050553323: cap 1: End par conjunction: 0x2515c30 +19050553449: cap 1: End par conjunct: 0x2515bd0 +19050553584: cap 1: End par conjunction: 0x2515bd0 +19050553710: cap 1: End par conjunct: 0x2515b70 +19050553840: cap 1: End par conjunction: 0x2515b70 +19050553966: cap 1: End par conjunct: 0x2515b10 +19050554106: cap 1: End par conjunction: 0x2515b10 +19050554232: cap 1: End par conjunct: 0x2515ab0 +19050554358: cap 1: End par conjunction: 0x2515ab0 +19050554484: cap 1: End par conjunct: 0x2515a50 +19050554610: cap 1: End par conjunction: 0x2515a50 +19050554745: cap 1: End par conjunct: 0x25159f0 +19050554866: cap 1: End par conjunction: 0x25159f0 +19050554997: cap 1: End par conjunct: 0x2515990 +19050555123: cap 1: End par conjunction: 0x2515990 +19050555253: cap 1: End par conjunct: 0x2515930 +19050555384: cap 1: End par conjunction: 0x2515930 +19050555510: cap 1: End par conjunct: 0x25158d0 +19050555636: cap 1: End par conjunction: 0x25158d0 +19050555762: cap 1: End par conjunct: 0x2515870 +19050555897: cap 1: End par conjunction: 0x2515870 +19050556027: cap 1: End par conjunct: 0x2515810 +19050556153: cap 1: End par conjunction: 0x2515810 +19050556284: cap 1: End par conjunct: 0x25157b0 +19050556414: cap 1: End par conjunction: 0x25157b0 +19050556545: cap 1: End par conjunct: 0x2515750 +19050556671: cap 1: End par conjunction: 0x2515750 +19050556806: cap 1: End par conjunct: 0x25156f0 +19050556932: cap 1: End par conjunction: 0x25156f0 +19050557062: cap 1: End par conjunct: 0x2515690 +19050557193: cap 1: End par conjunction: 0x2515690 +19050557332: cap 1: End par conjunct: 0x2515630 +19050557458: cap 1: End par conjunction: 0x2515630 +19050557584: cap 1: End par conjunct: 0x25155d0 +19050557719: cap 1: End par conjunction: 0x25155d0 +19050557886: cap 1: End par conjunct: 0x2515570 +19050558016: cap 1: End par conjunction: 0x2515570 +19050558183: cap 1: End par conjunct: 0x2515510 +19050558318: cap 1: End par conjunction: 0x2515510 +19050558489: cap 1: End par conjunct: 0x25154b0 +19050558615: cap 1: End par conjunction: 0x25154b0 +19050558745: cap 1: End par conjunct: 0x2515450 +19050558876: cap 1: End par conjunction: 0x2515450 +19050559011: cap 1: End par conjunct: 0x25153f0 +19050559137: cap 1: End par conjunction: 0x25153f0 +19050559267: cap 1: End par conjunct: 0x2515390 +19050559393: cap 1: End par conjunction: 0x2515390 +19050559524: cap 1: End par conjunct: 0x2515330 +19050559650: cap 1: End par conjunction: 0x2515330 +19050559785: cap 1: End par conjunct: 0x25152d0 +19050559911: cap 1: End par conjunction: 0x25152d0 +19050560041: cap 1: End par conjunct: 0x2515270 +19050560176: cap 1: End par conjunction: 0x2515270 +19050560307: cap 1: End par conjunct: 0x2515210 +19050560433: cap 1: End par conjunction: 0x2515210 +19050560563: cap 1: End par conjunct: 0x25151b0 +19050560698: cap 1: End par conjunction: 0x25151b0 +19050560829: cap 1: End par conjunct: 0x2515150 +19050560959: cap 1: End par conjunction: 0x2515150 +19242613692: cap 1: stopping thread 1 (thread yielding) +19242620163: cap 1: thread 1 is runnable +19242629086: cap 1: Looking for global thread to resume +19242629793: cap 1: Trying to steal a spark +19242642051: cap 0: running thread 1 +19242646272: cap 0: stopping thread 1 (thread finished) +19242695434: cap 2: Releasing thread 2 to the free pool +19242695605: removed cap 1 from capset 0 +19242696145: cap 1: shutting down +19242697063: removed cap 2 from capset 0 +19242697405: cap 2: shutting down +19242699354: cap 3: Releasing thread 3 to the free pool +19242701365: removed cap 3 from capset 0 +19242701919: cap 3: shutting down +19242931954: removed cap 0 from capset 0 +19242932310: cap 0: shutting down +19243048770: deleted capset 0 + + diff --git a/test/mdlLogMPI1.eventlog.reference b/test/mdlLogMPI1.eventlog.reference new file mode 100644 --- /dev/null +++ b/test/mdlLogMPI1.eventlog.reference @@ -0,0 +1,3629 @@ +Event Types: + 0: Create thread (size 4) + 1: Run thread (size 4) + 2: Stop thread (size 10) + 3: Thread runnable (size 4) + 4: Migrate thread (size 6) + 7: Shutdown (size 0) + 8: Wakeup thread (size 6) + 9: Starting GC (size 0) + 10: Finished GC (size 0) + 11: Request sequential GC (size 0) + 12: Request parallel GC (size 0) + 15: Create spark thread (size 4) + 16: Log message (size variable) + 17: Startup (size 2) + 18: Block marker (size 14) + 19: User message (size variable) + 20: GC idle (size 0) + 21: GC working (size 0) + 22: GC done (size 0) + 23: Version (size variable) + 24: Program invocation (size variable) + 25: Create capability set (size 6) + 26: Delete capability set (size 4) + 27: Add capability to capability set (size 6) + 28: Remove capability from capability set (size 6) + 29: RTS name and version (size variable) + 30: Program arguments (size variable) + 31: Program environment variables (size variable) + 32: Process ID (size 8) + 33: Parent process ID (size 8) + 34: Spark counters (size 56) + 35: Spark create (size 0) + 36: Spark dud (size 0) + 37: Spark overflow (size 0) + 38: Spark run (size 0) + 39: Spark steal (size 2) + 40: Spark fizzle (size 0) + 41: Spark GC (size 0) + 43: Wall clock time (size 16) + 44: Thread label (size variable) + 60: Starting message receival (size 0) + 61: Finished message receival (size 0) + 62: Creating Process (size 4) + 63: Killing Process (size 4) + 64: Assigning thread to process (size 8) + 65: Creating machine (size 10) + 66: Killing machine (size 2) + 67: Sending message (size 19) + 68: Receiving message (size 23) + 69: Sending/Receiving local message (size 17) + +Events: + 19499000: startup: 1 capabilities + 3000: creating machine 1 at 18446744072558799480 + 19503000: compiler version is 7.5.20111229 + 19506000: program invocation: jost=mdlLogMPI 2 +RTS -l -RTS 10 200 200 + 19511000: created capset 0 of type CapsetOsProcess + 19512000: created capset 1 of type CapsetClockDomain + 19514000: assigned cap 0 to capset 0 + 19516000: assigned cap 0 to capset 1 + 19520000: capset 1: wall clock time 1325869964s 883846000ns (unix epoch) + 19523000: capset 0: pid 10110 + 19526000: capset 0: parent pid 10109 + 19530000: capset 0: RTS version "GHC-7.5.20111229 rts_debug_pm" + 19532000: capset 0: args: ["jost=mdlLogMPI","+RTS","-l","-RTS","10","200","200"] + 19537000: capset 0: env: ["OMPI_MCA_orte_precondition_transports=a26f2412209a61f5-364fa122416e260c","ORBIT_SOCKETDIR=/tmp/orbit-jost","ATISTREAMSDKSAMPLEROOT=/opt/ati-stream-sdk-v2.3-lnx32","GPG_AGENT_INFO=/tmp/seahorse-BYAiMn/S.gpg-agent:1893:1","PVM_RSH=ssh","SHELL=/bin/bash","TERM=xterm","XDG_SESSION_COOKIE=ffab047df008bf9112f4eb2549e523e1-1325866751.93800-1887441509","CUDASDKROOT=/opt/Cuda-openCL-misc/Cuda-SDK-ubuntu/cuda","GLOBUS_LOCATION=/opt/globus","WINDOWID=71303172","GNOME_KEYRING_CONTROL=/tmp/keyring-XnV3Ki","PABLO_ROOT=/opt/EdenGHC/Pablo","GTK_MODULES=canberra-gtk-module","USER=jost","LS_COLORS=rs=0:di=01;34:ln=01;36:hl=44;37:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:su=37;41:sg=30;43:ca=30;41:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.lzma=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.rar=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01;35:*.svgz=01;35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.flv=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.axv=01;35:*.anx=01;35:*.ogv=01;35:*.ogx=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:*.axa=00;36:*.oga=00;36:*.spx=00;36:*.xspf=00;36:","LD_LIBRARY_PATH=/opt/Cuda-openCL-misc/Cuda-SDK-ubuntu/cuda/lib:/opt/ati-stream-sdk-v2.3-lnx32/lib/x86:/opt/globus/lib","EC2_HOME=/opt/ec2-api-tools-1.3-34128","SSH_AUTH_SOCK=/tmp/keyring-XnV3Ki/ssh","PVM_ROOT=/opt/EdenGHC/pvm3","USERNAME=jost","SESSION_MANAGER=local/ibm-jost:@/tmp/.ICE-unix/1849,unix/ibm-jost:/tmp/.ICE-unix/1849","DEFAULTS_PATH=/usr/share/gconf/gnome.default.path","ATISTREAMSDKROOT=/opt/ati-stream-sdk-v2.3-lnx32","PVM_ARCH=LINUX","XDG_CONFIG_DIRS=/etc/xdg/xdg-gnome:/etc/xdg","PATH=/opt/Cuda-openCL-misc/Cuda-SDK-ubuntu/cuda/bin:/home/jost/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/opt/bin:/home/jost/.cabal/bin","DESKTOP_SESSION=gnome","_=./mdlLogMPI","PWD=/opt2/EdenGHC/darcs-edentest","JAVA_HOME=/usr/lib/jvm/java-6-sun","GDM_KEYBOARD_LAYOUT=dk","GNOME_KEYRING_PID=1831","LANG=en_DK.utf8","GDM_LANG=en_DK.utf8","MANDATORY_PATH=/usr/share/gconf/gnome.mandatory.path","GDMSESSION=gnome","HISTCONTROL=ignoreboth","SPEECHD_PORT=7560","TEXINPUTS=/home/jost/texmf:","HOME=/home/jost","SHLVL=1","GNOME_DESKTOP_SESSION_ID=this-is-deprecated","LOGNAME=jost","DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-2FumsJTp4s,guid=4ba373624b700fa54dbcc0394f071eff","XDG_DATA_DIRS=/usr/share/gnome:/usr/local/share/:/usr/share/","DARCS_EDITOR=emacs","LESSOPEN=| /usr/bin/lesspipe %s","DISPLAY=:0.0","EC2_PRIVATE_KEY=/home/jost/.amazon-keys/amazon-pk-MA6BWW7H6T6IGTAV5QIWU54PQDET2A7U.pem","LESSCLOSE=/usr/bin/lesspipe %s %s","COLORTERM=gnome-terminal","XAUTHORITY=/var/run/gdm/auth-for-jost-bN54Qk/database","EC2_CERT=/home/jost/.amazon-keys/amazon-cert-MA6BWW7H6T6IGTAV5QIWU54PQDET2A7U.pem","OMPI_MCA_orte_local_daemon_uri=1342570496.0;tcp://127.0.0.1:44967","OMPI_MCA_orte_hnp_uri=1342570496.0;tcp://127.0.0.1:44967","OMPI_MCA_mpi_yield_when_idle=0","OMPI_MCA_orte_app_num=0","OMPI_UNIVERSE_SIZE=1","OMPI_MCA_ess=env","OMPI_MCA_orte_ess_num_procs=2","OMPI_COMM_WORLD_SIZE=2","OMPI_COMM_WORLD_LOCAL_SIZE=2","OMPI_MCA_orte_ess_jobid=1342570497","OMPI_MCA_orte_ess_vpid=0","OMPI_COMM_WORLD_RANK=0","OMPI_COMM_WORLD_LOCAL_RANK=0","OMPI_MCA_opal_cr_is_tool=0","OPAL_OUTPUT_STDERR_FD=18"] + 19673000: cap 0: creating thread 1 + 19679000: creating process 1 + 19681000: cap 0: assigning thread 1 to process 1 + 19695000: cap 0: running thread 1 + 19971000: newInport(1,1,1), blackhole 0xb1d03514 + + 19974000: newInport(1,1,2), blackhole 0xb1d0351c + + 20024000: sending message with tag RFork from process 1, thread 0 to machine 2, process 0 on inport 0 + 20030000: cap 0: creating thread 2 + 20033000: cap 0: assigning thread 2 to process 1 + 20038000: newInport(1,1,3), blackhole 0xb1d03924 + + 20040000: newInport(1,1,4), blackhole 0xb1d0392c + + 20174000: sending message with tag RFork from process 1, thread 0 to machine 1, process 0 on inport 0 + 20176000: cap 0: creating thread 3 + 20178000: cap 0: assigning thread 3 to process 1 + 20184000: cap 0: creating thread 4 + 20186000: cap 0: assigning thread 4 to process 1 + 20188000: cap 0: creating thread 5 + 20190000: cap 0: assigning thread 5 to process 1 + 20193000: cap 0: stopping thread 1 (blocked on an MVar) + 20210000: cap 0: starting to receive + 20213000: cap 0: receiving message with tag RFork at process 0, inport 0 from machine 1, process 1, thread 0 with size 38 + 20232000: cap 0: creating thread 6 + 20234000: creating process 2 + 20235000: cap 0: assigning thread 6 to process 2 + 20253000: cap 0: receiving message with tag DataMes at process 1, inport 2 from machine 2, process 1, thread 1 with size 9 + 20259000: cap 0: stop receiving + 20261000: cap 0: running thread 2 + 20265000: connectTSO (1,_,2) to inport (2,1,1) + + 20279000: sending message with tag Connect from process 1, thread 2 to machine 2, process 1 on inport 1 + 20290000: cap 0: stopping thread 2 (thread yielding) + 20293000: cap 0: running thread 3 + 20297000: cap 0: stopping thread 3 (blocked on black hole owned by thread 1) + 20300000: cap 0: running thread 4 + 20305000: cap 0: stopping thread 4 (blocked on black hole owned by thread 1) + 20308000: cap 0: running thread 5 + 20310000: cap 0: stopping thread 5 (blocked on black hole owned by thread 1) + 20312000: cap 0: running thread 6 + 20316000: newInport(1,2,5), blackhole 0xb1d07d14 + + 20318000: connectTSO (1,_,6) to inport (1,1,4) + + 20321000: sending/receiving message with tag DataMes from process 2, thread 6 to process 1 on inport 4 + 20323000: cap 0: waking up thread 3 on cap 0 + 20328000: connectTSO (1,_,6) to inport (1,1,3) + + 20334000: sending message with tag Connect from process 2, thread 6 to machine 1, process 1 on inport 3 + 20337000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 20342000: cap 0: starting to receive + 20344000: cap 0: stop receiving + 20345000: cap 0: running thread 2 + 20426000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20461000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20482000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20501000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20519000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20540000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20560000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20579000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20921000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20947000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 20954000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 20957000: cap 0: running thread 3 + 20961000: connectTSO (1,_,3) to inport (1,2,5) + + 20969000: sending message with tag Connect from process 1, thread 3 to machine 1, process 2 on inport 5 + 20972000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20974000: cap 0: waking up thread 6 on cap 0 + 20977000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20979000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20981000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20984000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20986000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20988000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20991000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20993000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20995000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 20998000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 21002000: cap 0: starting to receive + 21123000: COMM CHECK FAILED + + 21129000: cap 0: stop receiving + 21131000: cap 0: running thread 6 + 21531000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 21533000: cap 0: waking up thread 5 on cap 0 + 21852000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 22175000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 22502000: cap 0: stopping thread 6 (heap overflow) + 22504000: cap 0: starting GC + 22520000: cap 0: GC working + 23570000: cap 0: GC idle + 23572000: cap 0: GC done + 23575000: cap 0: GC idle + 23577000: cap 0: GC done + 23579000: cap 0: GC idle + 23580000: cap 0: GC done + 23583000: cap 0: GC idle + 23584000: cap 0: GC done + 23619000: cap 0: finished GC + 25224000: cap 0: starting to receive + 25341000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 25344000: cap 0: waking up thread 4 on cap 0 + 26634000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 26740000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 26842000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 26946000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1010 + 27049000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 27150000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 27217000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 825 + 27317000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 27419000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 27422000: cap 0: stop receiving + 27424000: cap 0: running thread 6 + 27515000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 27768000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 28018000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 28271000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 28345000: cap 0: stopping thread 6 (heap overflow) + 28347000: cap 0: starting GC + 28357000: cap 0: GC working + 34384000: cap 0: GC idle + 34386000: cap 0: GC done + 34390000: cap 0: GC idle + 34392000: cap 0: GC done + 34393000: cap 0: GC idle + 34395000: cap 0: GC done + 34397000: cap 0: GC idle + 34399000: cap 0: GC done + 34414000: cap 0: finished GC + 34429000: cap 0: running thread 6 + 34448000: cap 0: stopping thread 6 (thread yielding) + 34451000: cap 0: running thread 5 + 34459000: cap 0: waking up thread 1 on cap 0 + 34461000: cap 0: stopping thread 5 (blocked on an MVar) + 34464000: cap 0: running thread 4 + 34466000: cap 0: stopping thread 4 (blocked on an MVar) + 34468000: cap 0: running thread 6 + 34652000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 34915000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 35195000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 35198000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 35201000: cap 0: running thread 1 + 35204000: cap 0: waking up thread 5 on cap 0 + 35206000: cap 0: waking up thread 2 on cap 0 + 35212000: cap 0: stopping thread 1 (blocked on an MVar) + 35214000: cap 0: running thread 5 + 35216000: cap 0: waking up thread 1 on cap 0 + 35218000: cap 0: stopping thread 5 (blocked on an MVar) + 35220000: cap 0: running thread 2 + 35222000: cap 0: waking up thread 3 on cap 0 + 35226000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 35228000: cap 0: running thread 1 + 35230000: cap 0: waking up thread 4 on cap 0 + 35232000: cap 0: waking up thread 2 on cap 0 + 35236000: cap 0: stopping thread 1 (blocked on an MVar) + 35239000: cap 0: running thread 3 + 35242000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 35244000: cap 0: waking up thread 6 on cap 0 + 35246000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 35248000: cap 0: running thread 2 + 35250000: cap 0: waking up thread 3 on cap 0 + 35253000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 35255000: cap 0: running thread 4 + 35257000: cap 0: waking up thread 1 on cap 0 + 35259000: cap 0: stopping thread 4 (blocked on an MVar) + 35261000: cap 0: running thread 6 + 35541000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 35544000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 35547000: cap 0: running thread 3 + 35549000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 35551000: cap 0: waking up thread 6 on cap 0 + 35553000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 35555000: cap 0: running thread 1 + 35558000: cap 0: waking up thread 5 on cap 0 + 35560000: cap 0: waking up thread 2 on cap 0 + 35564000: cap 0: stopping thread 1 (blocked on an MVar) + 35566000: cap 0: running thread 6 + 35583000: cap 0: stopping thread 6 (heap overflow) + 35585000: cap 0: starting GC + 35594000: cap 0: GC working + 36115000: cap 0: GC idle + 36117000: cap 0: GC done + 36119000: cap 0: GC idle + 36121000: cap 0: GC done + 36123000: cap 0: GC idle + 36124000: cap 0: GC done + 36126000: cap 0: GC idle + 36127000: cap 0: GC done + 36136000: cap 0: finished GC + 36139000: cap 0: running thread 6 + 36383000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 36386000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 36389000: cap 0: running thread 5 + 36391000: cap 0: waking up thread 1 on cap 0 + 36393000: cap 0: stopping thread 5 (blocked on an MVar) + 36396000: cap 0: running thread 2 + 36398000: cap 0: waking up thread 3 on cap 0 + 36426000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 36429000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 36432000: cap 0: running thread 1 + 36434000: cap 0: waking up thread 4 on cap 0 + 36437000: cap 0: waking up thread 2 on cap 0 + 36441000: cap 0: stopping thread 1 (blocked on an MVar) + 36443000: cap 0: running thread 3 + 36445000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 36448000: cap 0: running thread 2 + 36450000: cap 0: waking up thread 3 on cap 0 + 36452000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 36454000: cap 0: running thread 4 + 36456000: cap 0: waking up thread 1 on cap 0 + 36458000: cap 0: stopping thread 4 (blocked on an MVar) + 36460000: cap 0: running thread 3 + 36463000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 36465000: cap 0: waking up thread 6 on cap 0 + 36467000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 36469000: cap 0: running thread 1 + 36472000: cap 0: waking up thread 5 on cap 0 + 36474000: cap 0: waking up thread 2 on cap 0 + 36478000: cap 0: stopping thread 1 (blocked on an MVar) + 36481000: cap 0: running thread 6 + 36746000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 36749000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 36751000: cap 0: running thread 5 + 36753000: cap 0: waking up thread 1 on cap 0 + 36756000: cap 0: stopping thread 5 (blocked on an MVar) + 36758000: cap 0: running thread 2 + 36759000: cap 0: waking up thread 3 on cap 0 + 36779000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 36782000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 36785000: cap 0: running thread 1 + 36787000: cap 0: waking up thread 4 on cap 0 + 36789000: cap 0: waking up thread 2 on cap 0 + 36793000: cap 0: stopping thread 1 (blocked on an MVar) + 36796000: cap 0: running thread 3 + 36798000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 36800000: cap 0: running thread 2 + 36802000: cap 0: waking up thread 3 on cap 0 + 36804000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 36806000: cap 0: running thread 4 + 36808000: cap 0: waking up thread 1 on cap 0 + 36810000: cap 0: stopping thread 4 (blocked on an MVar) + 36812000: cap 0: running thread 3 + 36815000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 36817000: cap 0: waking up thread 6 on cap 0 + 36819000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 36821000: cap 0: running thread 1 + 36823000: cap 0: waking up thread 5 on cap 0 + 36825000: cap 0: waking up thread 2 on cap 0 + 36829000: cap 0: stopping thread 1 (blocked on an MVar) + 36832000: cap 0: running thread 6 + 37098000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 37101000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 37107000: cap 0: running thread 5 + 37109000: cap 0: waking up thread 1 on cap 0 + 37111000: cap 0: stopping thread 5 (blocked on an MVar) + 37196000: cap 0: starting to receive + 37297000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 37300000: cap 0: stop receiving + 37302000: cap 0: running thread 2 + 37304000: cap 0: waking up thread 3 on cap 0 + 37324000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 37327000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 37329000: cap 0: running thread 1 + 37332000: cap 0: waking up thread 4 on cap 0 + 37334000: cap 0: waking up thread 2 on cap 0 + 37338000: cap 0: stopping thread 1 (blocked on an MVar) + 37340000: cap 0: running thread 3 + 37342000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 37344000: cap 0: running thread 2 + 37346000: cap 0: waking up thread 3 on cap 0 + 37349000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 37351000: cap 0: running thread 4 + 37353000: cap 0: waking up thread 1 on cap 0 + 37355000: cap 0: stopping thread 4 (blocked on an MVar) + 37357000: cap 0: running thread 3 + 37359000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 37361000: cap 0: waking up thread 6 on cap 0 + 37364000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 37366000: cap 0: running thread 1 + 37368000: cap 0: waking up thread 5 on cap 0 + 37370000: cap 0: waking up thread 2 on cap 0 + 37374000: cap 0: stopping thread 1 (blocked on an MVar) + 37377000: cap 0: running thread 6 + 37574000: cap 0: stopping thread 6 (heap overflow) + 37576000: cap 0: starting GC + 37585000: cap 0: GC working + 37850000: cap 0: GC idle + 37851000: cap 0: GC done + 37854000: cap 0: GC idle + 37855000: cap 0: GC done + 37857000: cap 0: GC idle + 37859000: cap 0: GC done + 37860000: cap 0: GC idle + 37862000: cap 0: GC done + 37870000: cap 0: finished GC + 37875000: cap 0: running thread 6 + 37948000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 37951000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 37958000: cap 0: starting to receive + 38036000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 887 + 38140000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 38143000: cap 0: stop receiving + 38145000: cap 0: running thread 5 + 38147000: cap 0: waking up thread 1 on cap 0 + 38150000: cap 0: stopping thread 5 (blocked on an MVar) + 38152000: cap 0: running thread 2 + 38154000: cap 0: waking up thread 3 on cap 0 + 38175000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 38178000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 38181000: cap 0: running thread 1 + 38183000: cap 0: waking up thread 4 on cap 0 + 38185000: cap 0: waking up thread 2 on cap 0 + 38189000: cap 0: stopping thread 1 (blocked on an MVar) + 38192000: cap 0: running thread 3 + 38194000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 38196000: cap 0: running thread 2 + 38198000: cap 0: waking up thread 3 on cap 0 + 38200000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 38203000: cap 0: running thread 4 + 38205000: cap 0: waking up thread 1 on cap 0 + 38210000: cap 0: stopping thread 4 (blocked on an MVar) + 38212000: cap 0: running thread 3 + 38215000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 38217000: cap 0: waking up thread 6 on cap 0 + 38219000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 38222000: cap 0: running thread 1 + 38224000: cap 0: waking up thread 5 on cap 0 + 38226000: cap 0: waking up thread 2 on cap 0 + 38230000: cap 0: stopping thread 1 (blocked on an MVar) + 38232000: cap 0: running thread 6 + 38525000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 38528000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 38531000: cap 0: running thread 5 + 38533000: cap 0: waking up thread 1 on cap 0 + 38535000: cap 0: stopping thread 5 (blocked on an MVar) + 38537000: cap 0: running thread 2 + 38539000: cap 0: waking up thread 3 on cap 0 + 38560000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 38562000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 38565000: cap 0: running thread 1 + 38568000: cap 0: waking up thread 4 on cap 0 + 38570000: cap 0: waking up thread 2 on cap 0 + 38574000: cap 0: stopping thread 1 (blocked on an MVar) + 38576000: cap 0: running thread 3 + 38578000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 38580000: cap 0: running thread 2 + 38582000: cap 0: waking up thread 3 on cap 0 + 38585000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 38587000: cap 0: running thread 4 + 38589000: cap 0: waking up thread 1 on cap 0 + 38591000: cap 0: stopping thread 4 (blocked on an MVar) + 38593000: cap 0: running thread 3 + 38596000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 38598000: cap 0: waking up thread 6 on cap 0 + 38600000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 38602000: cap 0: running thread 1 + 38604000: cap 0: waking up thread 5 on cap 0 + 38606000: cap 0: waking up thread 2 on cap 0 + 38610000: cap 0: stopping thread 1 (blocked on an MVar) + 38613000: cap 0: running thread 6 + 38885000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 38888000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 38892000: cap 0: running thread 5 + 38894000: cap 0: waking up thread 1 on cap 0 + 38896000: cap 0: stopping thread 5 (blocked on an MVar) + 39099000: cap 0: starting to receive + 39201000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 39306000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 39309000: cap 0: stop receiving + 39311000: cap 0: running thread 2 + 39313000: cap 0: waking up thread 3 on cap 0 + 39339000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 39342000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 39345000: cap 0: running thread 1 + 39347000: cap 0: waking up thread 4 on cap 0 + 39350000: cap 0: waking up thread 2 on cap 0 + 39356000: cap 0: stopping thread 1 (blocked on an MVar) + 39358000: cap 0: running thread 3 + 39360000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 39363000: cap 0: running thread 2 + 39364000: cap 0: waking up thread 3 on cap 0 + 39367000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 39369000: cap 0: running thread 4 + 39372000: cap 0: waking up thread 1 on cap 0 + 39374000: cap 0: stopping thread 4 (blocked on an MVar) + 39377000: cap 0: running thread 3 + 39379000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 39381000: cap 0: waking up thread 6 on cap 0 + 39384000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 39386000: cap 0: running thread 1 + 39388000: cap 0: waking up thread 5 on cap 0 + 39390000: cap 0: waking up thread 2 on cap 0 + 39394000: cap 0: stopping thread 1 (blocked on an MVar) + 39396000: cap 0: running thread 6 + 39681000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 39683000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 39687000: cap 0: running thread 5 + 39689000: cap 0: waking up thread 1 on cap 0 + 39691000: cap 0: stopping thread 5 (blocked on an MVar) + 39693000: cap 0: running thread 2 + 39695000: cap 0: waking up thread 3 on cap 0 + 39711000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 39714000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 39717000: cap 0: running thread 1 + 39719000: cap 0: waking up thread 4 on cap 0 + 39721000: cap 0: waking up thread 2 on cap 0 + 39726000: cap 0: stopping thread 1 (blocked on an MVar) + 39728000: cap 0: running thread 3 + 39730000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 39732000: cap 0: running thread 2 + 39734000: cap 0: waking up thread 3 on cap 0 + 39736000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 39738000: cap 0: running thread 4 + 39740000: cap 0: waking up thread 1 on cap 0 + 39742000: cap 0: stopping thread 4 (blocked on an MVar) + 39744000: cap 0: running thread 3 + 39747000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 39749000: cap 0: waking up thread 6 on cap 0 + 39751000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 39753000: cap 0: running thread 1 + 39755000: cap 0: waking up thread 5 on cap 0 + 39757000: cap 0: waking up thread 2 on cap 0 + 39761000: cap 0: stopping thread 1 (blocked on an MVar) + 39764000: cap 0: running thread 6 + 39835000: cap 0: stopping thread 6 (heap overflow) + 39838000: cap 0: starting GC + 39846000: cap 0: GC working + 40236000: cap 0: GC idle + 40238000: cap 0: GC done + 40240000: cap 0: GC idle + 40242000: cap 0: GC done + 40244000: cap 0: GC idle + 40245000: cap 0: GC done + 40247000: cap 0: GC idle + 40248000: cap 0: GC done + 40256000: cap 0: finished GC + 40261000: cap 0: running thread 6 + 40462000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 40465000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 40472000: cap 0: starting to receive + 40558000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 931 + 40662000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 40664000: cap 0: stop receiving + 40666000: cap 0: running thread 5 + 40668000: cap 0: waking up thread 1 on cap 0 + 40671000: cap 0: stopping thread 5 (blocked on an MVar) + 40673000: cap 0: running thread 2 + 40675000: cap 0: waking up thread 3 on cap 0 + 40692000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 40695000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 40698000: cap 0: running thread 1 + 40700000: cap 0: waking up thread 4 on cap 0 + 40702000: cap 0: waking up thread 2 on cap 0 + 40707000: cap 0: stopping thread 1 (blocked on an MVar) + 40709000: cap 0: running thread 3 + 40711000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 40713000: cap 0: running thread 2 + 40715000: cap 0: waking up thread 3 on cap 0 + 40717000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 40720000: cap 0: running thread 4 + 40722000: cap 0: waking up thread 1 on cap 0 + 40724000: cap 0: stopping thread 4 (blocked on an MVar) + 40726000: cap 0: running thread 3 + 40728000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 40730000: cap 0: waking up thread 6 on cap 0 + 40733000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 40735000: cap 0: running thread 1 + 40737000: cap 0: waking up thread 5 on cap 0 + 40739000: cap 0: waking up thread 2 on cap 0 + 40743000: cap 0: stopping thread 1 (blocked on an MVar) + 40745000: cap 0: running thread 6 + 41020000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 41023000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 41026000: cap 0: running thread 5 + 41028000: cap 0: waking up thread 1 on cap 0 + 41030000: cap 0: stopping thread 5 (blocked on an MVar) + 41032000: cap 0: running thread 2 + 41034000: cap 0: waking up thread 3 on cap 0 + 41049000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 41052000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 41055000: cap 0: running thread 1 + 41057000: cap 0: waking up thread 4 on cap 0 + 41059000: cap 0: waking up thread 2 on cap 0 + 41064000: cap 0: stopping thread 1 (blocked on an MVar) + 41066000: cap 0: running thread 3 + 41068000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 41070000: cap 0: running thread 2 + 41072000: cap 0: waking up thread 3 on cap 0 + 41074000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 41076000: cap 0: running thread 4 + 41078000: cap 0: waking up thread 1 on cap 0 + 41080000: cap 0: stopping thread 4 (blocked on an MVar) + 41082000: cap 0: running thread 3 + 41085000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 41087000: cap 0: waking up thread 6 on cap 0 + 41089000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 41091000: cap 0: running thread 1 + 41093000: cap 0: waking up thread 5 on cap 0 + 41095000: cap 0: waking up thread 2 on cap 0 + 41099000: cap 0: stopping thread 1 (blocked on an MVar) + 41102000: cap 0: running thread 6 + 41397000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 41400000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 41404000: cap 0: running thread 5 + 41406000: cap 0: waking up thread 1 on cap 0 + 41408000: cap 0: stopping thread 5 (blocked on an MVar) + 41532000: cap 0: starting to receive + 41632000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 41636000: cap 0: stop receiving + 41638000: cap 0: running thread 2 + 41640000: cap 0: waking up thread 3 on cap 0 + 41656000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 41658000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 41663000: cap 0: starting to receive + 41729000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 820 + 41731000: cap 0: stop receiving + 41733000: cap 0: running thread 1 + 41735000: cap 0: waking up thread 4 on cap 0 + 41737000: cap 0: waking up thread 2 on cap 0 + 41742000: cap 0: stopping thread 1 (blocked on an MVar) + 41744000: cap 0: running thread 3 + 41746000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 41748000: cap 0: running thread 2 + 41750000: cap 0: waking up thread 3 on cap 0 + 41753000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 41755000: cap 0: running thread 4 + 41757000: cap 0: waking up thread 1 on cap 0 + 41759000: cap 0: stopping thread 4 (blocked on an MVar) + 41761000: cap 0: running thread 3 + 41764000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 41766000: cap 0: waking up thread 6 on cap 0 + 41768000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 41770000: cap 0: running thread 1 + 41772000: cap 0: waking up thread 5 on cap 0 + 41774000: cap 0: waking up thread 2 on cap 0 + 41778000: cap 0: stopping thread 1 (blocked on an MVar) + 41780000: cap 0: running thread 6 + 41984000: cap 0: stopping thread 6 (heap overflow) + 41986000: cap 0: starting GC + 41994000: cap 0: GC working + 42361000: cap 0: GC idle + 42372000: cap 0: GC done + 42374000: cap 0: GC idle + 42376000: cap 0: GC done + 42377000: cap 0: GC idle + 42379000: cap 0: GC done + 42381000: cap 0: GC idle + 42382000: cap 0: GC done + 42390000: cap 0: finished GC + 42395000: cap 0: running thread 6 + 42473000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 42476000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 42482000: cap 0: starting to receive + 42584000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 42587000: cap 0: stop receiving + 42589000: cap 0: running thread 5 + 42591000: cap 0: waking up thread 1 on cap 0 + 42593000: cap 0: stopping thread 5 (blocked on an MVar) + 42596000: cap 0: running thread 2 + 42598000: cap 0: waking up thread 3 on cap 0 + 42614000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 42617000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 42620000: cap 0: running thread 1 + 42622000: cap 0: waking up thread 4 on cap 0 + 42624000: cap 0: waking up thread 2 on cap 0 + 42629000: cap 0: stopping thread 1 (blocked on an MVar) + 42631000: cap 0: running thread 3 + 42633000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 42635000: cap 0: running thread 2 + 42637000: cap 0: waking up thread 3 on cap 0 + 42640000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 42642000: cap 0: running thread 4 + 42644000: cap 0: waking up thread 1 on cap 0 + 42646000: cap 0: stopping thread 4 (blocked on an MVar) + 42648000: cap 0: running thread 3 + 42651000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 42653000: cap 0: waking up thread 6 on cap 0 + 42655000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 42657000: cap 0: running thread 1 + 42659000: cap 0: waking up thread 5 on cap 0 + 42661000: cap 0: waking up thread 2 on cap 0 + 42665000: cap 0: stopping thread 1 (blocked on an MVar) + 42667000: cap 0: running thread 6 + 42948000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 42951000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 42953000: cap 0: running thread 5 + 42955000: cap 0: waking up thread 1 on cap 0 + 42957000: cap 0: stopping thread 5 (blocked on an MVar) + 42960000: cap 0: running thread 2 + 42962000: cap 0: waking up thread 3 on cap 0 + 42977000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 42980000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 42983000: cap 0: running thread 1 + 42985000: cap 0: waking up thread 4 on cap 0 + 42987000: cap 0: waking up thread 2 on cap 0 + 42991000: cap 0: stopping thread 1 (blocked on an MVar) + 42997000: cap 0: running thread 3 + 43000000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 43002000: cap 0: running thread 2 + 43003000: cap 0: waking up thread 3 on cap 0 + 43006000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 43008000: cap 0: running thread 4 + 43010000: cap 0: waking up thread 1 on cap 0 + 43012000: cap 0: stopping thread 4 (blocked on an MVar) + 43014000: cap 0: running thread 3 + 43017000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 43019000: cap 0: waking up thread 6 on cap 0 + 43021000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 43023000: cap 0: running thread 1 + 43025000: cap 0: waking up thread 5 on cap 0 + 43027000: cap 0: waking up thread 2 on cap 0 + 43031000: cap 0: stopping thread 1 (blocked on an MVar) + 43034000: cap 0: running thread 6 + 43321000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 43324000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 43328000: cap 0: running thread 5 + 43329000: cap 0: waking up thread 1 on cap 0 + 43332000: cap 0: stopping thread 5 (blocked on an MVar) + 43542000: cap 0: starting to receive + 50741000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 50873000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 + 50876000: cap 0: stop receiving + 50880000: cap 0: running thread 2 + 50883000: cap 0: waking up thread 3 on cap 0 + 50910000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 50916000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 50919000: cap 0: running thread 1 + 50925000: cap 0: waking up thread 4 on cap 0 + 50928000: cap 0: waking up thread 2 on cap 0 + 50937000: cap 0: stopping thread 1 (blocked on an MVar) + 50940000: cap 0: running thread 3 + 50942000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 50944000: cap 0: running thread 2 + 50946000: cap 0: waking up thread 3 on cap 0 + 50949000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 50951000: cap 0: running thread 4 + 50953000: cap 0: waking up thread 1 on cap 0 + 50956000: cap 0: stopping thread 4 (blocked on an MVar) + 50959000: cap 0: running thread 3 + 50962000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 50964000: cap 0: waking up thread 6 on cap 0 + 50966000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 50968000: cap 0: running thread 1 + 50971000: cap 0: waking up thread 5 on cap 0 + 50973000: cap 0: waking up thread 2 on cap 0 + 50977000: cap 0: stopping thread 1 (blocked on an MVar) + 50980000: cap 0: running thread 6 + 50990000: cap 0: stopping thread 6 (thread yielding) + 50993000: cap 0: running thread 5 + 50995000: cap 0: waking up thread 1 on cap 0 + 50997000: cap 0: stopping thread 5 (blocked on an MVar) + 51000000: cap 0: running thread 2 + 51001000: cap 0: waking up thread 3 on cap 0 + 51017000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 51020000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 51023000: cap 0: running thread 1 + 51025000: cap 0: waking up thread 4 on cap 0 + 51027000: cap 0: waking up thread 2 on cap 0 + 51032000: cap 0: stopping thread 1 (blocked on an MVar) + 51034000: cap 0: running thread 6 + 51329000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 51332000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 51335000: cap 0: running thread 3 + 51337000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 51339000: cap 0: running thread 2 + 51341000: cap 0: waking up thread 3 on cap 0 + 51343000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 51346000: cap 0: running thread 4 + 51348000: cap 0: waking up thread 1 on cap 0 + 51350000: cap 0: stopping thread 4 (blocked on an MVar) + 51352000: cap 0: running thread 3 + 51355000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 51357000: cap 0: waking up thread 6 on cap 0 + 51359000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 51361000: cap 0: running thread 1 + 51363000: cap 0: waking up thread 5 on cap 0 + 51365000: cap 0: waking up thread 2 on cap 0 + 51369000: cap 0: stopping thread 1 (blocked on an MVar) + 51372000: cap 0: running thread 6 + 51404000: cap 0: stopping thread 6 (heap overflow) + 51406000: cap 0: starting GC + 51417000: cap 0: GC working + 51850000: cap 0: GC idle + 51851000: cap 0: GC done + 51854000: cap 0: GC idle + 51855000: cap 0: GC done + 51857000: cap 0: GC idle + 51859000: cap 0: GC done + 51861000: cap 0: GC idle + 51862000: cap 0: GC done + 51870000: cap 0: finished GC + 51876000: cap 0: running thread 6 + 52163000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 52166000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 52174000: cap 0: starting to receive + 52255000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 914 + 52359000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 52362000: cap 0: stop receiving + 52364000: cap 0: running thread 5 + 52366000: cap 0: waking up thread 1 on cap 0 + 52368000: cap 0: stopping thread 5 (blocked on an MVar) + 52371000: cap 0: running thread 2 + 52373000: cap 0: waking up thread 3 on cap 0 + 52390000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 52392000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 52395000: cap 0: running thread 1 + 52397000: cap 0: waking up thread 4 on cap 0 + 52400000: cap 0: waking up thread 2 on cap 0 + 52404000: cap 0: stopping thread 1 (blocked on an MVar) + 52406000: cap 0: running thread 3 + 52409000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 52411000: cap 0: running thread 2 + 52412000: cap 0: waking up thread 3 on cap 0 + 52415000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 52417000: cap 0: running thread 4 + 52419000: cap 0: waking up thread 1 on cap 0 + 52421000: cap 0: stopping thread 4 (blocked on an MVar) + 52424000: cap 0: running thread 3 + 52426000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 52428000: cap 0: waking up thread 6 on cap 0 + 52431000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 52433000: cap 0: running thread 1 + 52435000: cap 0: waking up thread 5 on cap 0 + 52437000: cap 0: waking up thread 2 on cap 0 + 52444000: cap 0: stopping thread 1 (blocked on an MVar) + 52446000: cap 0: running thread 6 + 52831000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 52833000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 52836000: cap 0: running thread 5 + 52838000: cap 0: waking up thread 1 on cap 0 + 52840000: cap 0: stopping thread 5 (blocked on an MVar) + 52842000: cap 0: running thread 2 + 52844000: cap 0: waking up thread 3 on cap 0 + 52860000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 52863000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 52865000: cap 0: running thread 1 + 52868000: cap 0: waking up thread 4 on cap 0 + 52870000: cap 0: waking up thread 2 on cap 0 + 52874000: cap 0: stopping thread 1 (blocked on an MVar) + 52876000: cap 0: running thread 3 + 52878000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 52881000: cap 0: running thread 2 + 52882000: cap 0: waking up thread 3 on cap 0 + 52885000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 52889000: cap 0: running thread 4 + 52891000: cap 0: waking up thread 1 on cap 0 + 52893000: cap 0: stopping thread 4 (blocked on an MVar) + 52909000: cap 0: starting to receive + 53008000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 53011000: cap 0: stop receiving + 53012000: cap 0: running thread 3 + 53015000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 53017000: cap 0: waking up thread 6 on cap 0 + 53020000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 53022000: cap 0: running thread 1 + 53024000: cap 0: waking up thread 5 on cap 0 + 53026000: cap 0: waking up thread 2 on cap 0 + 53031000: cap 0: stopping thread 1 (blocked on an MVar) + 53033000: cap 0: running thread 6 + 53481000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 53484000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 53488000: cap 0: running thread 5 + 53490000: cap 0: waking up thread 1 on cap 0 + 53492000: cap 0: stopping thread 5 (blocked on an MVar) + 53497000: cap 0: starting to receive + 53597000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1007 + 53600000: cap 0: stop receiving + 53601000: cap 0: running thread 2 + 53603000: cap 0: waking up thread 3 on cap 0 + 53620000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 53622000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 53625000: cap 0: running thread 1 + 53627000: cap 0: waking up thread 4 on cap 0 + 53630000: cap 0: waking up thread 2 on cap 0 + 53634000: cap 0: stopping thread 1 (blocked on an MVar) + 53636000: cap 0: running thread 3 + 53638000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 53641000: cap 0: running thread 2 + 53642000: cap 0: waking up thread 3 on cap 0 + 53645000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 53647000: cap 0: running thread 4 + 53649000: cap 0: waking up thread 1 on cap 0 + 53651000: cap 0: stopping thread 4 (blocked on an MVar) + 53653000: cap 0: running thread 3 + 53656000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 53658000: cap 0: waking up thread 6 on cap 0 + 53660000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 53662000: cap 0: running thread 1 + 53664000: cap 0: waking up thread 5 on cap 0 + 53666000: cap 0: waking up thread 2 on cap 0 + 53671000: cap 0: stopping thread 1 (blocked on an MVar) + 53673000: cap 0: running thread 6 + 54049000: cap 0: stopping thread 6 (heap overflow) + 54051000: cap 0: starting GC + 54059000: cap 0: GC working + 54468000: cap 0: GC idle + 54470000: cap 0: GC done + 54472000: cap 0: GC idle + 54474000: cap 0: GC done + 54475000: cap 0: GC idle + 54477000: cap 0: GC done + 54479000: cap 0: GC idle + 54480000: cap 0: GC done + 54489000: cap 0: finished GC + 54494000: cap 0: running thread 6 + 54609000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 54612000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 54618000: cap 0: starting to receive + 54719000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1004 + 54722000: cap 0: stop receiving + 54724000: cap 0: running thread 5 + 54726000: cap 0: waking up thread 1 on cap 0 + 54728000: cap 0: stopping thread 5 (blocked on an MVar) + 54731000: cap 0: running thread 2 + 54733000: cap 0: waking up thread 3 on cap 0 + 54749000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 54752000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 54755000: cap 0: running thread 1 + 54757000: cap 0: waking up thread 4 on cap 0 + 54759000: cap 0: waking up thread 2 on cap 0 + 54764000: cap 0: stopping thread 1 (blocked on an MVar) + 54766000: cap 0: running thread 3 + 54768000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 54771000: cap 0: running thread 2 + 54772000: cap 0: waking up thread 3 on cap 0 + 54775000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 54777000: cap 0: running thread 4 + 54779000: cap 0: waking up thread 1 on cap 0 + 54781000: cap 0: stopping thread 4 (blocked on an MVar) + 54783000: cap 0: running thread 3 + 54786000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 54788000: cap 0: waking up thread 6 on cap 0 + 54790000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 54792000: cap 0: running thread 1 + 54794000: cap 0: waking up thread 5 on cap 0 + 54796000: cap 0: waking up thread 2 on cap 0 + 54801000: cap 0: stopping thread 1 (blocked on an MVar) + 54803000: cap 0: running thread 6 + 55260000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 55263000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 55266000: cap 0: running thread 5 + 55268000: cap 0: waking up thread 1 on cap 0 + 55270000: cap 0: stopping thread 5 (blocked on an MVar) + 55272000: cap 0: running thread 2 + 55274000: cap 0: waking up thread 3 on cap 0 + 55290000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 55293000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 55295000: cap 0: running thread 1 + 55297000: cap 0: waking up thread 4 on cap 0 + 55299000: cap 0: waking up thread 2 on cap 0 + 55304000: cap 0: stopping thread 1 (blocked on an MVar) + 55306000: cap 0: running thread 3 + 55308000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 55310000: cap 0: running thread 2 + 55312000: cap 0: waking up thread 3 on cap 0 + 55314000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 55316000: cap 0: running thread 4 + 55318000: cap 0: waking up thread 1 on cap 0 + 55320000: cap 0: stopping thread 4 (blocked on an MVar) + 55322000: cap 0: running thread 3 + 55325000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 55327000: cap 0: waking up thread 6 on cap 0 + 55329000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 55331000: cap 0: running thread 1 + 55333000: cap 0: waking up thread 5 on cap 0 + 55335000: cap 0: waking up thread 2 on cap 0 + 55340000: cap 0: stopping thread 1 (blocked on an MVar) + 55343000: cap 0: running thread 6 + 55773000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 55776000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 55787000: cap 0: running thread 5 + 55789000: cap 0: waking up thread 1 on cap 0 + 55791000: cap 0: stopping thread 5 (blocked on an MVar) + 55980000: cap 0: starting to receive + 56080000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1005 + 56182000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1007 + 56185000: cap 0: stop receiving + 56187000: cap 0: running thread 2 + 56189000: cap 0: waking up thread 3 on cap 0 + 56205000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 56208000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 56210000: cap 0: running thread 1 + 56213000: cap 0: waking up thread 4 on cap 0 + 56215000: cap 0: waking up thread 2 on cap 0 + 56220000: cap 0: stopping thread 1 (blocked on an MVar) + 56222000: cap 0: running thread 3 + 56224000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 56226000: cap 0: running thread 2 + 56228000: cap 0: waking up thread 3 on cap 0 + 56230000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 56232000: cap 0: running thread 4 + 56234000: cap 0: waking up thread 1 on cap 0 + 56236000: cap 0: stopping thread 4 (blocked on an MVar) + 56239000: cap 0: running thread 3 + 56241000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 56243000: cap 0: waking up thread 6 on cap 0 + 56245000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 56248000: cap 0: running thread 1 + 56250000: cap 0: waking up thread 5 on cap 0 + 56251000: cap 0: waking up thread 2 on cap 0 + 56256000: cap 0: stopping thread 1 (blocked on an MVar) + 56258000: cap 0: running thread 6 + 56851000: cap 0: stopping thread 6 (heap overflow) + 56853000: cap 0: starting GC + 56862000: cap 0: GC working + 57206000: cap 0: GC idle + 57208000: cap 0: GC done + 57210000: cap 0: GC idle + 57211000: cap 0: GC done + 57213000: cap 0: GC idle + 57215000: cap 0: GC done + 57217000: cap 0: GC idle + 57218000: cap 0: GC done + 57226000: cap 0: finished GC + 57231000: cap 0: running thread 6 + 57236000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 57239000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 57244000: cap 0: starting to receive + 57326000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 913 + 57329000: cap 0: stop receiving + 57331000: cap 0: running thread 5 + 57333000: cap 0: waking up thread 1 on cap 0 + 57335000: cap 0: stopping thread 5 (blocked on an MVar) + 57338000: cap 0: running thread 2 + 57340000: cap 0: waking up thread 3 on cap 0 + 57356000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 57359000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 57362000: cap 0: running thread 1 + 57364000: cap 0: waking up thread 4 on cap 0 + 57366000: cap 0: waking up thread 2 on cap 0 + 57370000: cap 0: stopping thread 1 (blocked on an MVar) + 57373000: cap 0: running thread 3 + 57375000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 57377000: cap 0: running thread 2 + 57379000: cap 0: waking up thread 3 on cap 0 + 57381000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 57384000: cap 0: running thread 4 + 57386000: cap 0: waking up thread 1 on cap 0 + 57388000: cap 0: stopping thread 4 (blocked on an MVar) + 57390000: cap 0: running thread 3 + 57392000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 57394000: cap 0: waking up thread 6 on cap 0 + 57397000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 57399000: cap 0: running thread 1 + 57401000: cap 0: waking up thread 5 on cap 0 + 57403000: cap 0: waking up thread 2 on cap 0 + 57407000: cap 0: stopping thread 1 (blocked on an MVar) + 57409000: cap 0: running thread 6 + 58156000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 58159000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 58162000: cap 0: running thread 5 + 58163000: cap 0: waking up thread 1 on cap 0 + 58166000: cap 0: stopping thread 5 (blocked on an MVar) + 58168000: cap 0: running thread 2 + 58170000: cap 0: waking up thread 3 on cap 0 + 58186000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 58189000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 58192000: cap 0: running thread 1 + 58195000: cap 0: waking up thread 4 on cap 0 + 58197000: cap 0: waking up thread 2 on cap 0 + 58201000: cap 0: stopping thread 1 (blocked on an MVar) + 58205000: cap 0: starting to receive + 58302000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 995 + 58305000: cap 0: stop receiving + 58306000: cap 0: running thread 3 + 58309000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 58311000: cap 0: running thread 2 + 58313000: cap 0: waking up thread 3 on cap 0 + 58315000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 58317000: cap 0: running thread 4 + 58319000: cap 0: waking up thread 1 on cap 0 + 58321000: cap 0: stopping thread 4 (blocked on an MVar) + 58323000: cap 0: running thread 3 + 58326000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 58328000: cap 0: waking up thread 6 on cap 0 + 58330000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 58333000: cap 0: running thread 1 + 58335000: cap 0: waking up thread 5 on cap 0 + 58337000: cap 0: waking up thread 2 on cap 0 + 58341000: cap 0: stopping thread 1 (blocked on an MVar) + 58344000: cap 0: running thread 6 + 65885000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 65890000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 65904000: cap 0: running thread 5 + 65907000: cap 0: waking up thread 1 on cap 0 + 65910000: cap 0: stopping thread 5 (blocked on an MVar) + 65916000: cap 0: starting to receive + 66016000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 989 + 66018000: cap 0: stop receiving + 66020000: cap 0: running thread 2 + 66022000: cap 0: waking up thread 3 on cap 0 + 66043000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 66046000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 66049000: cap 0: running thread 1 + 66052000: cap 0: waking up thread 4 on cap 0 + 66054000: cap 0: waking up thread 2 on cap 0 + 66060000: cap 0: stopping thread 1 (blocked on an MVar) + 66063000: cap 0: running thread 3 + 66065000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 66067000: cap 0: running thread 2 + 66069000: cap 0: waking up thread 3 on cap 0 + 66071000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 66074000: cap 0: running thread 4 + 66076000: cap 0: waking up thread 1 on cap 0 + 66078000: cap 0: stopping thread 4 (blocked on an MVar) + 66080000: cap 0: running thread 3 + 66083000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 66085000: cap 0: waking up thread 6 on cap 0 + 66087000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 66089000: cap 0: running thread 1 + 66091000: cap 0: waking up thread 5 on cap 0 + 66093000: cap 0: waking up thread 2 on cap 0 + 66099000: cap 0: stopping thread 1 (blocked on an MVar) + 66101000: cap 0: running thread 6 + 67040000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 67043000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 67049000: cap 0: running thread 5 + 67051000: cap 0: waking up thread 1 on cap 0 + 67053000: cap 0: stopping thread 5 (blocked on an MVar) + 67057000: cap 0: starting to receive + 67154000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 985 + 67156000: cap 0: stop receiving + 67158000: cap 0: running thread 2 + 67160000: cap 0: waking up thread 3 on cap 0 + 67177000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 67179000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 67182000: cap 0: running thread 1 + 67184000: cap 0: waking up thread 4 on cap 0 + 67187000: cap 0: waking up thread 2 on cap 0 + 67191000: cap 0: stopping thread 1 (blocked on an MVar) + 67193000: cap 0: running thread 3 + 67195000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 67198000: cap 0: running thread 2 + 67199000: cap 0: waking up thread 3 on cap 0 + 67202000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 67204000: cap 0: running thread 4 + 67206000: cap 0: waking up thread 1 on cap 0 + 67208000: cap 0: stopping thread 4 (blocked on an MVar) + 67210000: cap 0: running thread 3 + 67213000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 67215000: cap 0: waking up thread 6 on cap 0 + 67217000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 67220000: cap 0: running thread 1 + 67222000: cap 0: waking up thread 5 on cap 0 + 67224000: cap 0: waking up thread 2 on cap 0 + 67228000: cap 0: stopping thread 1 (blocked on an MVar) + 67230000: cap 0: running thread 6 + 68243000: cap 0: stopping thread 6 (heap overflow) + 68245000: cap 0: starting GC + 68256000: cap 0: GC working + 68697000: cap 0: GC idle + 68699000: cap 0: GC done + 68701000: cap 0: GC idle + 68703000: cap 0: GC done + 68705000: cap 0: GC idle + 68706000: cap 0: GC done + 68708000: cap 0: GC idle + 68710000: cap 0: GC done + 68718000: cap 0: finished GC + 68723000: cap 0: running thread 6 + 68750000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 68753000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 68758000: cap 0: starting to receive + 68842000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 919 + 68844000: cap 0: stop receiving + 68846000: cap 0: running thread 5 + 68848000: cap 0: waking up thread 1 on cap 0 + 68850000: cap 0: stopping thread 5 (blocked on an MVar) + 68853000: cap 0: running thread 2 + 68855000: cap 0: waking up thread 3 on cap 0 + 68872000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 68875000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 68877000: cap 0: running thread 1 + 68880000: cap 0: waking up thread 4 on cap 0 + 68882000: cap 0: waking up thread 2 on cap 0 + 68886000: cap 0: stopping thread 1 (blocked on an MVar) + 68889000: cap 0: running thread 3 + 68891000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 68893000: cap 0: running thread 2 + 68895000: cap 0: waking up thread 3 on cap 0 + 68897000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 68899000: cap 0: running thread 4 + 68901000: cap 0: waking up thread 1 on cap 0 + 68903000: cap 0: stopping thread 4 (blocked on an MVar) + 68905000: cap 0: running thread 3 + 68908000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 68910000: cap 0: waking up thread 6 on cap 0 + 68912000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 68915000: cap 0: running thread 1 + 68917000: cap 0: waking up thread 5 on cap 0 + 68918000: cap 0: waking up thread 2 on cap 0 + 68923000: cap 0: stopping thread 1 (blocked on an MVar) + 68925000: cap 0: running thread 6 + 69670000: cap 0: stopping thread 6 (thread yielding) + 69674000: cap 0: running thread 5 + 69676000: cap 0: waking up thread 1 on cap 0 + 69678000: cap 0: stopping thread 5 (blocked on an MVar) + 69680000: cap 0: running thread 2 + 69682000: cap 0: waking up thread 3 on cap 0 + 69699000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 69702000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 69704000: cap 0: running thread 1 + 69707000: cap 0: waking up thread 4 on cap 0 + 69709000: cap 0: waking up thread 2 on cap 0 + 69713000: cap 0: stopping thread 1 (blocked on an MVar) + 69715000: cap 0: running thread 6 + 69963000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 69966000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 69968000: cap 0: running thread 3 + 69970000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 69973000: cap 0: running thread 2 + 69974000: cap 0: waking up thread 3 on cap 0 + 69977000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 69979000: cap 0: running thread 4 + 69981000: cap 0: waking up thread 1 on cap 0 + 69983000: cap 0: stopping thread 4 (blocked on an MVar) + 69985000: cap 0: running thread 3 + 69988000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 69990000: cap 0: waking up thread 6 on cap 0 + 69992000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 69995000: cap 0: running thread 1 + 69997000: cap 0: waking up thread 5 on cap 0 + 69999000: cap 0: waking up thread 2 on cap 0 + 70004000: cap 0: stopping thread 1 (blocked on an MVar) + 70007000: cap 0: running thread 6 + 72135000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 72138000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 72145000: cap 0: running thread 5 + 72147000: cap 0: waking up thread 1 on cap 0 + 72150000: cap 0: stopping thread 5 (blocked on an MVar) + 72157000: cap 0: starting to receive + 72252000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 971 + 72349000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 977 + 72351000: cap 0: stop receiving + 72353000: cap 0: running thread 2 + 72355000: cap 0: waking up thread 3 on cap 0 + 72373000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 72376000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 72379000: cap 0: running thread 1 + 72382000: cap 0: waking up thread 4 on cap 0 + 72384000: cap 0: waking up thread 2 on cap 0 + 72390000: cap 0: stopping thread 1 (blocked on an MVar) + 72392000: cap 0: running thread 3 + 72394000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 72402000: cap 0: running thread 2 + 72404000: cap 0: waking up thread 3 on cap 0 + 72407000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 72409000: cap 0: running thread 4 + 72411000: cap 0: waking up thread 1 on cap 0 + 72413000: cap 0: stopping thread 4 (blocked on an MVar) + 72415000: cap 0: running thread 3 + 72418000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 72420000: cap 0: waking up thread 6 on cap 0 + 72422000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 72424000: cap 0: running thread 1 + 72426000: cap 0: waking up thread 5 on cap 0 + 72428000: cap 0: waking up thread 2 on cap 0 + 72433000: cap 0: stopping thread 1 (blocked on an MVar) + 72435000: cap 0: running thread 6 + 73469000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 73472000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 73475000: cap 0: running thread 5 + 73477000: cap 0: waking up thread 1 on cap 0 + 73479000: cap 0: stopping thread 5 (blocked on an MVar) + 73481000: cap 0: running thread 2 + 73483000: cap 0: waking up thread 3 on cap 0 + 73499000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 73502000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 73505000: cap 0: running thread 1 + 73507000: cap 0: waking up thread 4 on cap 0 + 73509000: cap 0: waking up thread 2 on cap 0 + 73513000: cap 0: stopping thread 1 (blocked on an MVar) + 73516000: cap 0: running thread 3 + 73518000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 73520000: cap 0: running thread 2 + 73522000: cap 0: waking up thread 3 on cap 0 + 73524000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 73526000: cap 0: running thread 4 + 73528000: cap 0: waking up thread 1 on cap 0 + 73530000: cap 0: stopping thread 4 (blocked on an MVar) + 73532000: cap 0: running thread 3 + 73535000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 73537000: cap 0: waking up thread 6 on cap 0 + 73539000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 73543000: cap 0: running thread 1 + 73545000: cap 0: waking up thread 5 on cap 0 + 73547000: cap 0: waking up thread 2 on cap 0 + 73551000: cap 0: stopping thread 1 (blocked on an MVar) + 73555000: cap 0: starting to receive + 73650000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 975 + 73653000: cap 0: stop receiving + 73655000: cap 0: running thread 6 + 74681000: cap 0: stopping thread 6 (heap overflow) + 74683000: cap 0: starting GC + 74693000: cap 0: GC working + 75370000: cap 0: GC idle + 75372000: cap 0: GC done + 75374000: cap 0: GC idle + 75376000: cap 0: GC done + 75378000: cap 0: GC idle + 75379000: cap 0: GC done + 75381000: cap 0: GC idle + 75382000: cap 0: GC done + 75391000: cap 0: finished GC + 75397000: cap 0: running thread 6 + 75437000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 75441000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 75446000: cap 0: starting to receive + 75526000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 900 + 75529000: cap 0: stop receiving + 75531000: cap 0: running thread 5 + 75533000: cap 0: waking up thread 1 on cap 0 + 75535000: cap 0: stopping thread 5 (blocked on an MVar) + 75538000: cap 0: running thread 2 + 75540000: cap 0: waking up thread 3 on cap 0 + 75557000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 75561000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 75563000: cap 0: running thread 1 + 75566000: cap 0: waking up thread 4 on cap 0 + 75568000: cap 0: waking up thread 2 on cap 0 + 75573000: cap 0: stopping thread 1 (blocked on an MVar) + 75575000: cap 0: running thread 3 + 75578000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 75579000: cap 0: running thread 2 + 75581000: cap 0: waking up thread 3 on cap 0 + 75584000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 75586000: cap 0: running thread 4 + 75588000: cap 0: waking up thread 1 on cap 0 + 75590000: cap 0: stopping thread 4 (blocked on an MVar) + 75592000: cap 0: running thread 3 + 75595000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 75597000: cap 0: waking up thread 6 on cap 0 + 75599000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 75602000: cap 0: running thread 1 + 75604000: cap 0: waking up thread 5 on cap 0 + 75605000: cap 0: waking up thread 2 on cap 0 + 75612000: cap 0: stopping thread 1 (blocked on an MVar) + 75614000: cap 0: running thread 6 + 76728000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 76731000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 76737000: cap 0: running thread 5 + 76739000: cap 0: waking up thread 1 on cap 0 + 76742000: cap 0: stopping thread 5 (blocked on an MVar) + 76744000: cap 0: running thread 2 + 76746000: cap 0: waking up thread 3 on cap 0 + 76762000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 76765000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 76769000: cap 0: running thread 1 + 76771000: cap 0: waking up thread 4 on cap 0 + 76773000: cap 0: waking up thread 2 on cap 0 + 76778000: cap 0: stopping thread 1 (blocked on an MVar) + 76782000: cap 0: starting to receive + 76877000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 974 + 76880000: cap 0: stop receiving + 76882000: cap 0: running thread 3 + 76884000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 76886000: cap 0: running thread 2 + 76888000: cap 0: waking up thread 3 on cap 0 + 76891000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 76893000: cap 0: running thread 4 + 76895000: cap 0: waking up thread 1 on cap 0 + 76897000: cap 0: stopping thread 4 (blocked on an MVar) + 76899000: cap 0: running thread 3 + 76902000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 76907000: cap 0: waking up thread 6 on cap 0 + 76910000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 76912000: cap 0: running thread 1 + 76914000: cap 0: waking up thread 5 on cap 0 + 76916000: cap 0: waking up thread 2 on cap 0 + 76920000: cap 0: stopping thread 1 (blocked on an MVar) + 76923000: cap 0: running thread 6 + 78004000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 78007000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 78010000: cap 0: running thread 5 + 78012000: cap 0: waking up thread 1 on cap 0 + 78014000: cap 0: stopping thread 5 (blocked on an MVar) + 78016000: cap 0: running thread 2 + 78018000: cap 0: waking up thread 3 on cap 0 + 78033000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 78036000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 78039000: cap 0: running thread 1 + 78041000: cap 0: waking up thread 4 on cap 0 + 78043000: cap 0: waking up thread 2 on cap 0 + 78048000: cap 0: stopping thread 1 (blocked on an MVar) + 78051000: cap 0: running thread 3 + 78053000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 78057000: cap 0: starting to receive + 78150000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 969 + 78153000: cap 0: stop receiving + 78154000: cap 0: running thread 2 + 78156000: cap 0: waking up thread 3 on cap 0 + 78159000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 78161000: cap 0: running thread 4 + 78163000: cap 0: waking up thread 1 on cap 0 + 78165000: cap 0: stopping thread 4 (blocked on an MVar) + 78168000: cap 0: running thread 3 + 78170000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 78172000: cap 0: waking up thread 6 on cap 0 + 78175000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 78177000: cap 0: running thread 1 + 78179000: cap 0: waking up thread 5 on cap 0 + 78181000: cap 0: waking up thread 2 on cap 0 + 78185000: cap 0: stopping thread 1 (blocked on an MVar) + 78187000: cap 0: running thread 6 + 79207000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 79210000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 79213000: cap 0: running thread 5 + 79215000: cap 0: waking up thread 1 on cap 0 + 79218000: cap 0: stopping thread 5 (blocked on an MVar) + 79220000: cap 0: running thread 2 + 79222000: cap 0: waking up thread 3 on cap 0 + 79238000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 79240000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 79244000: cap 0: running thread 1 + 79247000: cap 0: waking up thread 4 on cap 0 + 79249000: cap 0: waking up thread 2 on cap 0 + 79253000: cap 0: stopping thread 1 (blocked on an MVar) + 79257000: cap 0: starting to receive + 79351000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 975 + 79354000: cap 0: stop receiving + 79356000: cap 0: running thread 3 + 79358000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 79360000: cap 0: running thread 2 + 79362000: cap 0: waking up thread 3 on cap 0 + 79365000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 79367000: cap 0: running thread 4 + 79369000: cap 0: waking up thread 1 on cap 0 + 79371000: cap 0: stopping thread 4 (blocked on an MVar) + 79374000: cap 0: running thread 3 + 79376000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 79378000: cap 0: waking up thread 6 on cap 0 + 79380000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 79383000: cap 0: running thread 1 + 79385000: cap 0: waking up thread 5 on cap 0 + 79387000: cap 0: waking up thread 2 on cap 0 + 79391000: cap 0: stopping thread 1 (blocked on an MVar) + 79393000: cap 0: running thread 6 + 80416000: cap 0: stopping thread 6 (heap overflow) + 80418000: cap 0: starting GC + 80427000: cap 0: GC working + 80839000: cap 0: GC idle + 80841000: cap 0: GC done + 80843000: cap 0: GC idle + 80845000: cap 0: GC done + 80846000: cap 0: GC idle + 80848000: cap 0: GC done + 80850000: cap 0: GC idle + 80851000: cap 0: GC done + 80860000: cap 0: finished GC + 80865000: cap 0: running thread 6 + 80951000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 80954000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 80959000: cap 0: starting to receive + 81041000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 900 + 81044000: cap 0: stop receiving + 81046000: cap 0: running thread 5 + 81048000: cap 0: waking up thread 1 on cap 0 + 81050000: cap 0: stopping thread 5 (blocked on an MVar) + 81053000: cap 0: running thread 2 + 81055000: cap 0: waking up thread 3 on cap 0 + 81072000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 81075000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 81077000: cap 0: running thread 1 + 81080000: cap 0: waking up thread 4 on cap 0 + 81082000: cap 0: waking up thread 2 on cap 0 + 81086000: cap 0: stopping thread 1 (blocked on an MVar) + 81089000: cap 0: running thread 3 + 81091000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 81093000: cap 0: running thread 2 + 81095000: cap 0: waking up thread 3 on cap 0 + 81097000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 81099000: cap 0: running thread 4 + 81101000: cap 0: waking up thread 1 on cap 0 + 81103000: cap 0: stopping thread 4 (blocked on an MVar) + 81106000: cap 0: running thread 3 + 81108000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 81110000: cap 0: waking up thread 6 on cap 0 + 81113000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 81115000: cap 0: running thread 1 + 81117000: cap 0: waking up thread 5 on cap 0 + 81119000: cap 0: waking up thread 2 on cap 0 + 81124000: cap 0: stopping thread 1 (blocked on an MVar) + 81126000: cap 0: running thread 6 + 82148000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 82151000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 82154000: cap 0: running thread 5 + 82155000: cap 0: waking up thread 1 on cap 0 + 82158000: cap 0: stopping thread 5 (blocked on an MVar) + 82160000: cap 0: running thread 2 + 82162000: cap 0: waking up thread 3 on cap 0 + 82178000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 82181000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 82183000: cap 0: running thread 1 + 82186000: cap 0: waking up thread 4 on cap 0 + 82188000: cap 0: waking up thread 2 on cap 0 + 82192000: cap 0: stopping thread 1 (blocked on an MVar) + 82194000: cap 0: running thread 3 + 82196000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 82199000: cap 0: running thread 2 + 82200000: cap 0: waking up thread 3 on cap 0 + 82203000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 82205000: cap 0: running thread 4 + 82207000: cap 0: waking up thread 1 on cap 0 + 82209000: cap 0: stopping thread 4 (blocked on an MVar) + 82211000: cap 0: running thread 3 + 82213000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 82215000: cap 0: waking up thread 6 on cap 0 + 82218000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 82220000: cap 0: running thread 1 + 82222000: cap 0: waking up thread 5 on cap 0 + 82224000: cap 0: waking up thread 2 on cap 0 + 82228000: cap 0: stopping thread 1 (blocked on an MVar) + 82230000: cap 0: running thread 6 + 83221000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 83224000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 83228000: cap 0: running thread 5 + 83230000: cap 0: waking up thread 1 on cap 0 + 83232000: cap 0: stopping thread 5 (blocked on an MVar) + 83236000: cap 0: starting to receive + 83330000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 973 + 83337000: cap 0: stop receiving + 83339000: cap 0: running thread 2 + 83341000: cap 0: waking up thread 3 on cap 0 + 83357000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 83360000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 83363000: cap 0: running thread 1 + 83365000: cap 0: waking up thread 4 on cap 0 + 83367000: cap 0: waking up thread 2 on cap 0 + 83372000: cap 0: stopping thread 1 (blocked on an MVar) + 83374000: cap 0: running thread 3 + 83376000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 83378000: cap 0: running thread 2 + 83380000: cap 0: waking up thread 3 on cap 0 + 83382000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 83384000: cap 0: running thread 4 + 83386000: cap 0: waking up thread 1 on cap 0 + 83388000: cap 0: stopping thread 4 (blocked on an MVar) + 83390000: cap 0: running thread 3 + 83393000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 83395000: cap 0: waking up thread 6 on cap 0 + 83397000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 83399000: cap 0: running thread 1 + 83401000: cap 0: waking up thread 5 on cap 0 + 83403000: cap 0: waking up thread 2 on cap 0 + 83408000: cap 0: stopping thread 1 (blocked on an MVar) + 83410000: cap 0: running thread 6 + 84353000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 84356000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 84360000: cap 0: running thread 5 + 84362000: cap 0: waking up thread 1 on cap 0 + 84364000: cap 0: stopping thread 5 (blocked on an MVar) + 84368000: cap 0: starting to receive + 84465000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 977 + 84467000: cap 0: stop receiving + 84469000: cap 0: running thread 2 + 84471000: cap 0: waking up thread 3 on cap 0 + 84487000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 84490000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 84492000: cap 0: running thread 1 + 84495000: cap 0: waking up thread 4 on cap 0 + 84497000: cap 0: waking up thread 2 on cap 0 + 84501000: cap 0: stopping thread 1 (blocked on an MVar) + 84503000: cap 0: running thread 3 + 84505000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 84508000: cap 0: running thread 2 + 84509000: cap 0: waking up thread 3 on cap 0 + 84512000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 84514000: cap 0: running thread 4 + 84516000: cap 0: waking up thread 1 on cap 0 + 84518000: cap 0: stopping thread 4 (blocked on an MVar) + 84520000: cap 0: running thread 3 + 84522000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 84524000: cap 0: waking up thread 6 on cap 0 + 84527000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 84529000: cap 0: running thread 1 + 84531000: cap 0: waking up thread 5 on cap 0 + 84533000: cap 0: waking up thread 2 on cap 0 + 84537000: cap 0: stopping thread 1 (blocked on an MVar) + 84539000: cap 0: running thread 6 + 84620000: cap 0: stopping thread 6 (heap overflow) + 84622000: cap 0: starting GC + 84631000: cap 0: GC working + 84984000: cap 0: GC idle + 84985000: cap 0: GC done + 84988000: cap 0: GC idle + 84989000: cap 0: GC done + 84991000: cap 0: GC idle + 84993000: cap 0: GC done + 84994000: cap 0: GC idle + 84996000: cap 0: GC done + 85004000: cap 0: finished GC + 85009000: cap 0: running thread 6 + 85854000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 85857000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 85864000: cap 0: starting to receive + 85959000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 977 + 86047000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 937 + 86049000: cap 0: stop receiving + 86051000: cap 0: running thread 5 + 86053000: cap 0: waking up thread 1 on cap 0 + 86056000: cap 0: stopping thread 5 (blocked on an MVar) + 86058000: cap 0: running thread 2 + 86060000: cap 0: waking up thread 3 on cap 0 + 86077000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 86080000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 86083000: cap 0: running thread 1 + 86085000: cap 0: waking up thread 4 on cap 0 + 86087000: cap 0: waking up thread 2 on cap 0 + 86091000: cap 0: stopping thread 1 (blocked on an MVar) + 86094000: cap 0: running thread 3 + 86096000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 86099000: cap 0: running thread 2 + 86101000: cap 0: waking up thread 3 on cap 0 + 86103000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 86105000: cap 0: running thread 4 + 86107000: cap 0: waking up thread 1 on cap 0 + 86109000: cap 0: stopping thread 4 (blocked on an MVar) + 86112000: cap 0: running thread 3 + 86114000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 86116000: cap 0: waking up thread 6 on cap 0 + 86118000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 86121000: cap 0: running thread 1 + 86123000: cap 0: waking up thread 5 on cap 0 + 86125000: cap 0: waking up thread 2 on cap 0 + 86129000: cap 0: stopping thread 1 (blocked on an MVar) + 86131000: cap 0: running thread 6 + 86968000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 86971000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 86977000: cap 0: running thread 5 + 86979000: cap 0: waking up thread 1 on cap 0 + 86981000: cap 0: stopping thread 5 (blocked on an MVar) + 86984000: cap 0: running thread 2 + 86985000: cap 0: waking up thread 3 on cap 0 + 87001000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 87004000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 87007000: cap 0: running thread 1 + 87009000: cap 0: waking up thread 4 on cap 0 + 87011000: cap 0: waking up thread 2 on cap 0 + 87015000: cap 0: stopping thread 1 (blocked on an MVar) + 87018000: cap 0: running thread 3 + 87020000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 87022000: cap 0: running thread 2 + 87024000: cap 0: waking up thread 3 on cap 0 + 87026000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 87028000: cap 0: running thread 4 + 87030000: cap 0: waking up thread 1 on cap 0 + 87032000: cap 0: stopping thread 4 (blocked on an MVar) + 87034000: cap 0: running thread 3 + 87037000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 87039000: cap 0: waking up thread 6 on cap 0 + 87041000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 87043000: cap 0: running thread 1 + 87045000: cap 0: waking up thread 5 on cap 0 + 87047000: cap 0: waking up thread 2 on cap 0 + 87051000: cap 0: stopping thread 1 (blocked on an MVar) + 87054000: cap 0: running thread 6 + 87801000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 87804000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 87808000: cap 0: running thread 5 + 87810000: cap 0: waking up thread 1 on cap 0 + 87812000: cap 0: stopping thread 5 (blocked on an MVar) + 87816000: cap 0: starting to receive + 87913000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 985 + 87915000: cap 0: stop receiving + 87917000: cap 0: running thread 2 + 87919000: cap 0: waking up thread 3 on cap 0 + 87935000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 87938000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 87941000: cap 0: running thread 1 + 87943000: cap 0: waking up thread 4 on cap 0 + 87945000: cap 0: waking up thread 2 on cap 0 + 87950000: cap 0: stopping thread 1 (blocked on an MVar) + 87952000: cap 0: running thread 3 + 87954000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 87956000: cap 0: running thread 2 + 87958000: cap 0: waking up thread 3 on cap 0 + 87960000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 87962000: cap 0: running thread 4 + 87964000: cap 0: waking up thread 1 on cap 0 + 87966000: cap 0: stopping thread 4 (blocked on an MVar) + 87968000: cap 0: running thread 3 + 87971000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 87973000: cap 0: waking up thread 6 on cap 0 + 87975000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 87977000: cap 0: running thread 1 + 87979000: cap 0: waking up thread 5 on cap 0 + 87981000: cap 0: waking up thread 2 on cap 0 + 87986000: cap 0: stopping thread 1 (blocked on an MVar) + 87988000: cap 0: running thread 6 + 88416000: cap 0: stopping thread 6 (heap overflow) + 88418000: cap 0: starting GC + 88427000: cap 0: GC working + 88752000: cap 0: GC idle + 88753000: cap 0: GC done + 88756000: cap 0: GC idle + 88757000: cap 0: GC done + 88759000: cap 0: GC idle + 88760000: cap 0: GC done + 88762000: cap 0: GC idle + 88764000: cap 0: GC done + 88772000: cap 0: finished GC + 88776000: cap 0: running thread 6 + 88934000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 88937000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 88943000: cap 0: starting to receive + 89039000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 989 + 89119000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 891 + 89121000: cap 0: stop receiving + 89123000: cap 0: running thread 5 + 89125000: cap 0: waking up thread 1 on cap 0 + 89128000: cap 0: stopping thread 5 (blocked on an MVar) + 89130000: cap 0: running thread 2 + 89132000: cap 0: waking up thread 3 on cap 0 + 89148000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 89151000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 89154000: cap 0: running thread 1 + 89156000: cap 0: waking up thread 4 on cap 0 + 89158000: cap 0: waking up thread 2 on cap 0 + 89162000: cap 0: stopping thread 1 (blocked on an MVar) + 89165000: cap 0: running thread 3 + 89167000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 89169000: cap 0: running thread 2 + 89171000: cap 0: waking up thread 3 on cap 0 + 89173000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 89175000: cap 0: running thread 4 + 89177000: cap 0: waking up thread 1 on cap 0 + 89179000: cap 0: stopping thread 4 (blocked on an MVar) + 89182000: cap 0: running thread 3 + 89184000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 89186000: cap 0: waking up thread 6 on cap 0 + 89188000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 89191000: cap 0: running thread 1 + 89193000: cap 0: waking up thread 5 on cap 0 + 89195000: cap 0: waking up thread 2 on cap 0 + 89199000: cap 0: stopping thread 1 (blocked on an MVar) + 89201000: cap 0: running thread 6 + 89665000: cap 0: stopping thread 6 (thread yielding) + 89668000: cap 0: running thread 5 + 89670000: cap 0: waking up thread 1 on cap 0 + 89673000: cap 0: stopping thread 5 (blocked on an MVar) + 89675000: cap 0: running thread 2 + 89677000: cap 0: waking up thread 3 on cap 0 + 89693000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 89696000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 89699000: cap 0: running thread 1 + 89701000: cap 0: waking up thread 4 on cap 0 + 89703000: cap 0: waking up thread 2 on cap 0 + 89708000: cap 0: stopping thread 1 (blocked on an MVar) + 89710000: cap 0: running thread 6 + 90062000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 90065000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 90069000: cap 0: running thread 3 + 90072000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 90801000: cap 0: starting to receive + 90900000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1013 + 90995000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 985 + 90997000: cap 0: stop receiving + 90999000: cap 0: running thread 2 + 91001000: cap 0: waking up thread 3 on cap 0 + 91004000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 91006000: cap 0: running thread 4 + 91008000: cap 0: waking up thread 1 on cap 0 + 91011000: cap 0: stopping thread 4 (blocked on an MVar) + 91013000: cap 0: running thread 3 + 91016000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 91018000: cap 0: waking up thread 6 on cap 0 + 91020000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 91022000: cap 0: running thread 1 + 91024000: cap 0: waking up thread 5 on cap 0 + 91026000: cap 0: waking up thread 2 on cap 0 + 91031000: cap 0: stopping thread 1 (blocked on an MVar) + 91033000: cap 0: running thread 6 + 92051000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 92054000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 92057000: cap 0: running thread 5 + 92059000: cap 0: waking up thread 1 on cap 0 + 92061000: cap 0: stopping thread 5 (blocked on an MVar) + 92063000: cap 0: running thread 2 + 92065000: cap 0: waking up thread 3 on cap 0 + 92081000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 92084000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 92087000: cap 0: running thread 1 + 92089000: cap 0: waking up thread 4 on cap 0 + 92091000: cap 0: waking up thread 2 on cap 0 + 92095000: cap 0: stopping thread 1 (blocked on an MVar) + 92097000: cap 0: running thread 3 + 92099000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 92102000: cap 0: running thread 2 + 92104000: cap 0: waking up thread 3 on cap 0 + 92106000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 92108000: cap 0: running thread 4 + 92110000: cap 0: waking up thread 1 on cap 0 + 92116000: cap 0: stopping thread 4 (blocked on an MVar) + 92118000: cap 0: running thread 3 + 92121000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 92123000: cap 0: waking up thread 6 on cap 0 + 92125000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 92127000: cap 0: running thread 1 + 92129000: cap 0: waking up thread 5 on cap 0 + 92131000: cap 0: waking up thread 2 on cap 0 + 92136000: cap 0: stopping thread 1 (blocked on an MVar) + 92138000: cap 0: running thread 6 + 93250000: cap 0: stopping thread 6 (heap overflow) + 93252000: cap 0: starting GC + 93260000: cap 0: GC working + 93631000: cap 0: GC idle + 93633000: cap 0: GC done + 93635000: cap 0: GC idle + 93636000: cap 0: GC done + 93638000: cap 0: GC idle + 93640000: cap 0: GC done + 93642000: cap 0: GC idle + 93643000: cap 0: GC done + 93651000: cap 0: finished GC + 93657000: cap 0: running thread 6 + 93713000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 93716000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 93721000: cap 0: starting to receive + 93792000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 853 + 93794000: cap 0: stop receiving + 93796000: cap 0: running thread 5 + 93798000: cap 0: waking up thread 1 on cap 0 + 93801000: cap 0: stopping thread 5 (blocked on an MVar) + 93803000: cap 0: running thread 2 + 93805000: cap 0: waking up thread 3 on cap 0 + 93822000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 93824000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 93827000: cap 0: running thread 1 + 93830000: cap 0: waking up thread 4 on cap 0 + 93832000: cap 0: waking up thread 2 on cap 0 + 93836000: cap 0: stopping thread 1 (blocked on an MVar) + 93838000: cap 0: running thread 3 + 93840000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 93843000: cap 0: running thread 2 + 93844000: cap 0: waking up thread 3 on cap 0 + 93847000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 93849000: cap 0: running thread 4 + 93851000: cap 0: waking up thread 1 on cap 0 + 93853000: cap 0: stopping thread 4 (blocked on an MVar) + 93855000: cap 0: running thread 3 + 93858000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 93860000: cap 0: waking up thread 6 on cap 0 + 93862000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 93867000: cap 0: running thread 1 + 93869000: cap 0: waking up thread 5 on cap 0 + 93871000: cap 0: waking up thread 2 on cap 0 + 93875000: cap 0: stopping thread 1 (blocked on an MVar) + 93877000: cap 0: running thread 6 + 95231000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 95234000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 95237000: cap 0: running thread 5 + 95239000: cap 0: waking up thread 1 on cap 0 + 95241000: cap 0: stopping thread 5 (blocked on an MVar) + 95243000: cap 0: running thread 2 + 95245000: cap 0: waking up thread 3 on cap 0 + 95261000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 95263000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 95266000: cap 0: running thread 1 + 95268000: cap 0: waking up thread 4 on cap 0 + 95270000: cap 0: waking up thread 2 on cap 0 + 95275000: cap 0: stopping thread 1 (blocked on an MVar) + 95277000: cap 0: running thread 3 + 95279000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 95281000: cap 0: running thread 2 + 95283000: cap 0: waking up thread 3 on cap 0 + 95285000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 95287000: cap 0: running thread 4 + 95289000: cap 0: waking up thread 1 on cap 0 + 95291000: cap 0: stopping thread 4 (blocked on an MVar) + 95294000: cap 0: running thread 3 + 95296000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 95298000: cap 0: waking up thread 6 on cap 0 + 95300000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 95302000: cap 0: running thread 1 + 95304000: cap 0: waking up thread 5 on cap 0 + 95306000: cap 0: waking up thread 2 on cap 0 + 95310000: cap 0: stopping thread 1 (blocked on an MVar) + 95313000: cap 0: running thread 6 + 96845000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 96848000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 96852000: cap 0: running thread 5 + 96854000: cap 0: waking up thread 1 on cap 0 + 96856000: cap 0: stopping thread 5 (blocked on an MVar) + 96860000: cap 0: starting to receive + 96951000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 959 + 96955000: cap 0: stop receiving + 96957000: cap 0: running thread 2 + 96959000: cap 0: waking up thread 3 on cap 0 + 96975000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 96978000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 96982000: cap 0: starting to receive + 97073000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 955 + 97077000: cap 0: stop receiving + 97079000: cap 0: running thread 1 + 97081000: cap 0: waking up thread 4 on cap 0 + 97083000: cap 0: waking up thread 2 on cap 0 + 97088000: cap 0: stopping thread 1 (blocked on an MVar) + 97090000: cap 0: running thread 3 + 97092000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 97095000: cap 0: running thread 2 + 97096000: cap 0: waking up thread 3 on cap 0 + 97099000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 97101000: cap 0: running thread 4 + 97103000: cap 0: waking up thread 1 on cap 0 + 97105000: cap 0: stopping thread 4 (blocked on an MVar) + 97107000: cap 0: running thread 3 + 97110000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 97112000: cap 0: waking up thread 6 on cap 0 + 97114000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 97116000: cap 0: running thread 1 + 97118000: cap 0: waking up thread 5 on cap 0 + 97120000: cap 0: waking up thread 2 on cap 0 + 97125000: cap 0: stopping thread 1 (blocked on an MVar) + 97127000: cap 0: running thread 6 + 98754000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 + 98756000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) + 98761000: cap 0: running thread 5 + 98763000: cap 0: waking up thread 1 on cap 0 + 98765000: cap 0: stopping thread 5 (blocked on an MVar) + 98770000: cap 0: starting to receive + 98857000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 945 + 98859000: cap 0: stop receiving + 98861000: cap 0: running thread 2 + 98863000: cap 0: waking up thread 3 on cap 0 + 98879000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 + 98882000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 98885000: cap 0: running thread 1 + 98887000: cap 0: waking up thread 4 on cap 0 + 98889000: cap 0: waking up thread 2 on cap 0 + 98893000: cap 0: stopping thread 1 (blocked on an MVar) + 98896000: cap 0: running thread 3 + 98898000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 98900000: cap 0: running thread 2 + 98902000: cap 0: waking up thread 3 on cap 0 + 98904000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) + 98906000: cap 0: running thread 4 + 98908000: cap 0: waking up thread 1 on cap 0 + 98910000: cap 0: stopping thread 4 (blocked on an MVar) + 98913000: cap 0: running thread 3 + 98915000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 + 98917000: cap 0: waking up thread 6 on cap 0 + 98919000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) + 98922000: cap 0: running thread 1 + 98924000: cap 0: waking up thread 5 on cap 0 + 98925000: cap 0: waking up thread 2 on cap 0 + 98930000: cap 0: stopping thread 1 (blocked on an MVar) + 98932000: cap 0: running thread 6 +100500000: cap 0: stopping thread 6 (heap overflow) +100502000: cap 0: starting GC +100511000: cap 0: GC working +100919000: cap 0: GC idle +100920000: cap 0: GC done +100922000: cap 0: GC idle +100924000: cap 0: GC done +100925000: cap 0: GC idle +100927000: cap 0: GC done +100929000: cap 0: GC idle +100930000: cap 0: GC done +100939000: cap 0: finished GC +100944000: cap 0: running thread 6 +101011000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +101014000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +101019000: cap 0: starting to receive +101089000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 852 +101092000: cap 0: stop receiving +101094000: cap 0: running thread 5 +101096000: cap 0: waking up thread 1 on cap 0 +101098000: cap 0: stopping thread 5 (blocked on an MVar) +101100000: cap 0: running thread 2 +101102000: cap 0: waking up thread 3 on cap 0 +101119000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +101122000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +101124000: cap 0: running thread 1 +101127000: cap 0: waking up thread 4 on cap 0 +101129000: cap 0: waking up thread 2 on cap 0 +101133000: cap 0: stopping thread 1 (blocked on an MVar) +101135000: cap 0: running thread 3 +101138000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +101140000: cap 0: running thread 2 +101142000: cap 0: waking up thread 3 on cap 0 +101144000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +101146000: cap 0: running thread 4 +101148000: cap 0: waking up thread 1 on cap 0 +101150000: cap 0: stopping thread 4 (blocked on an MVar) +101152000: cap 0: running thread 3 +101155000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +101157000: cap 0: waking up thread 6 on cap 0 +101159000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +101162000: cap 0: running thread 1 +101164000: cap 0: waking up thread 5 on cap 0 +101166000: cap 0: waking up thread 2 on cap 0 +101170000: cap 0: stopping thread 1 (blocked on an MVar) +101172000: cap 0: running thread 6 +102875000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +102878000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +102881000: cap 0: running thread 5 +102883000: cap 0: waking up thread 1 on cap 0 +102886000: cap 0: stopping thread 5 (blocked on an MVar) +102888000: cap 0: running thread 2 +102890000: cap 0: waking up thread 3 on cap 0 +102906000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +102908000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +102913000: cap 0: running thread 1 +102915000: cap 0: waking up thread 4 on cap 0 +102918000: cap 0: waking up thread 2 on cap 0 +102922000: cap 0: stopping thread 1 (blocked on an MVar) +102926000: cap 0: starting to receive +103014000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 943 +103017000: cap 0: stop receiving +103018000: cap 0: running thread 3 +103021000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +103023000: cap 0: running thread 2 +103025000: cap 0: waking up thread 3 on cap 0 +103027000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +103029000: cap 0: running thread 4 +103031000: cap 0: waking up thread 1 on cap 0 +103033000: cap 0: stopping thread 4 (blocked on an MVar) +103035000: cap 0: running thread 3 +103038000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +103040000: cap 0: waking up thread 6 on cap 0 +103042000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +103045000: cap 0: running thread 1 +103047000: cap 0: waking up thread 5 on cap 0 +103049000: cap 0: waking up thread 2 on cap 0 +103053000: cap 0: stopping thread 1 (blocked on an MVar) +103055000: cap 0: running thread 6 +105184000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +105187000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +105193000: cap 0: running thread 5 +105195000: cap 0: waking up thread 1 on cap 0 +105197000: cap 0: stopping thread 5 (blocked on an MVar) +105201000: cap 0: starting to receive +105290000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 938 +105292000: cap 0: stop receiving +105294000: cap 0: running thread 2 +105296000: cap 0: waking up thread 3 on cap 0 +105312000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +105315000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +105318000: cap 0: running thread 1 +105321000: cap 0: waking up thread 4 on cap 0 +105323000: cap 0: waking up thread 2 on cap 0 +105328000: cap 0: stopping thread 1 (blocked on an MVar) +105330000: cap 0: running thread 3 +105332000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +105334000: cap 0: running thread 2 +105336000: cap 0: waking up thread 3 on cap 0 +105338000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +105341000: cap 0: running thread 4 +105342000: cap 0: waking up thread 1 on cap 0 +105344000: cap 0: stopping thread 4 (blocked on an MVar) +105347000: cap 0: running thread 3 +105349000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +105351000: cap 0: waking up thread 6 on cap 0 +105353000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +105356000: cap 0: running thread 1 +105358000: cap 0: waking up thread 5 on cap 0 +105360000: cap 0: waking up thread 2 on cap 0 +105364000: cap 0: stopping thread 1 (blocked on an MVar) +105366000: cap 0: running thread 6 +107484000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +107487000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +107495000: cap 0: running thread 5 +107497000: cap 0: waking up thread 1 on cap 0 +107499000: cap 0: stopping thread 5 (blocked on an MVar) +107503000: cap 0: starting to receive +107588000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 921 +107591000: cap 0: stop receiving +107592000: cap 0: running thread 2 +107601000: cap 0: waking up thread 3 on cap 0 +107618000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +107621000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +107624000: cap 0: running thread 1 +107626000: cap 0: waking up thread 4 on cap 0 +107628000: cap 0: waking up thread 2 on cap 0 +107633000: cap 0: stopping thread 1 (blocked on an MVar) +107635000: cap 0: running thread 3 +107637000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +107639000: cap 0: running thread 2 +107641000: cap 0: waking up thread 3 on cap 0 +107644000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +107646000: cap 0: running thread 4 +107648000: cap 0: waking up thread 1 on cap 0 +107650000: cap 0: stopping thread 4 (blocked on an MVar) +107652000: cap 0: running thread 3 +107655000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +107656000: cap 0: waking up thread 6 on cap 0 +107659000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +107661000: cap 0: running thread 1 +107663000: cap 0: waking up thread 5 on cap 0 +107665000: cap 0: waking up thread 2 on cap 0 +107669000: cap 0: stopping thread 1 (blocked on an MVar) +107671000: cap 0: running thread 6 +109663000: cap 0: stopping thread 6 (thread yielding) +109667000: cap 0: running thread 5 +109669000: cap 0: waking up thread 1 on cap 0 +109671000: cap 0: stopping thread 5 (blocked on an MVar) +109673000: cap 0: running thread 2 +109675000: cap 0: waking up thread 3 on cap 0 +109691000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +109694000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +109697000: cap 0: running thread 1 +109699000: cap 0: waking up thread 4 on cap 0 +109701000: cap 0: waking up thread 2 on cap 0 +109706000: cap 0: stopping thread 1 (blocked on an MVar) +109708000: cap 0: running thread 6 +109799000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +109802000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +109805000: cap 0: running thread 3 +109807000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +109809000: cap 0: running thread 2 +109811000: cap 0: waking up thread 3 on cap 0 +109813000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +109815000: cap 0: running thread 4 +109817000: cap 0: waking up thread 1 on cap 0 +109819000: cap 0: stopping thread 4 (blocked on an MVar) +109821000: cap 0: running thread 3 +109824000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +109826000: cap 0: waking up thread 6 on cap 0 +109828000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +109830000: cap 0: running thread 1 +109832000: cap 0: waking up thread 5 on cap 0 +109834000: cap 0: waking up thread 2 on cap 0 +109839000: cap 0: stopping thread 1 (blocked on an MVar) +109841000: cap 0: running thread 6 +109918000: cap 0: stopping thread 6 (heap overflow) +109920000: cap 0: starting GC +109930000: cap 0: GC working +110384000: cap 0: GC idle +110386000: cap 0: GC done +110388000: cap 0: GC idle +110390000: cap 0: GC done +110391000: cap 0: GC idle +110393000: cap 0: GC done +110395000: cap 0: GC idle +110396000: cap 0: GC done +110405000: cap 0: finished GC +110410000: cap 0: running thread 6 +112257000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +112260000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +112266000: cap 0: starting to receive +112350000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 917 +112429000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 878 +112431000: cap 0: stop receiving +112433000: cap 0: running thread 5 +112435000: cap 0: waking up thread 1 on cap 0 +112438000: cap 0: stopping thread 5 (blocked on an MVar) +112440000: cap 0: running thread 2 +112442000: cap 0: waking up thread 3 on cap 0 +112459000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +112461000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +112464000: cap 0: running thread 1 +112467000: cap 0: waking up thread 4 on cap 0 +112469000: cap 0: waking up thread 2 on cap 0 +112473000: cap 0: stopping thread 1 (blocked on an MVar) +112476000: cap 0: running thread 3 +112478000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +112480000: cap 0: running thread 2 +112482000: cap 0: waking up thread 3 on cap 0 +112484000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +112486000: cap 0: running thread 4 +112488000: cap 0: waking up thread 1 on cap 0 +112490000: cap 0: stopping thread 4 (blocked on an MVar) +112493000: cap 0: running thread 3 +112495000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +112497000: cap 0: waking up thread 6 on cap 0 +112500000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +112502000: cap 0: running thread 1 +112504000: cap 0: waking up thread 5 on cap 0 +112506000: cap 0: waking up thread 2 on cap 0 +112510000: cap 0: stopping thread 1 (blocked on an MVar) +112512000: cap 0: running thread 6 +114469000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +114471000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +114475000: cap 0: running thread 5 +114476000: cap 0: waking up thread 1 on cap 0 +114479000: cap 0: stopping thread 5 (blocked on an MVar) +114481000: cap 0: running thread 2 +114483000: cap 0: waking up thread 3 on cap 0 +114498000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +114501000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +114504000: cap 0: running thread 1 +114506000: cap 0: waking up thread 4 on cap 0 +114508000: cap 0: waking up thread 2 on cap 0 +114512000: cap 0: stopping thread 1 (blocked on an MVar) +114515000: cap 0: running thread 3 +114517000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +114519000: cap 0: running thread 2 +114521000: cap 0: waking up thread 3 on cap 0 +114523000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +114525000: cap 0: running thread 4 +114527000: cap 0: waking up thread 1 on cap 0 +114529000: cap 0: stopping thread 4 (blocked on an MVar) +114531000: cap 0: running thread 3 +114534000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +114536000: cap 0: waking up thread 6 on cap 0 +114538000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +114540000: cap 0: running thread 1 +114542000: cap 0: waking up thread 5 on cap 0 +114544000: cap 0: waking up thread 2 on cap 0 +114548000: cap 0: stopping thread 1 (blocked on an MVar) +114551000: cap 0: running thread 6 +116595000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +116598000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +116602000: cap 0: running thread 5 +116604000: cap 0: waking up thread 1 on cap 0 +116606000: cap 0: stopping thread 5 (blocked on an MVar) +116610000: cap 0: starting to receive +116692000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 925 +116695000: cap 0: stop receiving +116697000: cap 0: running thread 2 +116699000: cap 0: waking up thread 3 on cap 0 +116715000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +116718000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +116722000: cap 0: starting to receive +116805000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 923 +116808000: cap 0: stop receiving +116809000: cap 0: running thread 1 +116812000: cap 0: waking up thread 4 on cap 0 +116814000: cap 0: waking up thread 2 on cap 0 +116818000: cap 0: stopping thread 1 (blocked on an MVar) +116821000: cap 0: running thread 3 +116823000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +116825000: cap 0: running thread 2 +116827000: cap 0: waking up thread 3 on cap 0 +116829000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +116831000: cap 0: running thread 4 +116833000: cap 0: waking up thread 1 on cap 0 +116835000: cap 0: stopping thread 4 (blocked on an MVar) +116837000: cap 0: running thread 3 +116840000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +116842000: cap 0: waking up thread 6 on cap 0 +116844000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +116846000: cap 0: running thread 1 +116849000: cap 0: waking up thread 5 on cap 0 +116850000: cap 0: waking up thread 2 on cap 0 +116855000: cap 0: stopping thread 1 (blocked on an MVar) +116857000: cap 0: running thread 6 +118916000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +118919000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +118925000: cap 0: running thread 5 +118927000: cap 0: waking up thread 1 on cap 0 +118930000: cap 0: stopping thread 5 (blocked on an MVar) +118934000: cap 0: starting to receive +119017000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 921 +119019000: cap 0: stop receiving +119021000: cap 0: running thread 2 +119023000: cap 0: waking up thread 3 on cap 0 +119039000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +119042000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +119045000: cap 0: running thread 1 +119047000: cap 0: waking up thread 4 on cap 0 +119049000: cap 0: waking up thread 2 on cap 0 +119053000: cap 0: stopping thread 1 (blocked on an MVar) +119056000: cap 0: running thread 3 +119058000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +119060000: cap 0: running thread 2 +119062000: cap 0: waking up thread 3 on cap 0 +119064000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +119067000: cap 0: running thread 4 +119068000: cap 0: waking up thread 1 on cap 0 +119071000: cap 0: stopping thread 4 (blocked on an MVar) +119073000: cap 0: running thread 3 +119075000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +119077000: cap 0: waking up thread 6 on cap 0 +119080000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +119082000: cap 0: running thread 1 +119084000: cap 0: waking up thread 5 on cap 0 +119086000: cap 0: waking up thread 2 on cap 0 +119090000: cap 0: stopping thread 1 (blocked on an MVar) +119092000: cap 0: running thread 6 +122446000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +122449000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +122456000: cap 0: running thread 5 +122458000: cap 0: waking up thread 1 on cap 0 +122461000: cap 0: stopping thread 5 (blocked on an MVar) +122466000: cap 0: starting to receive +122551000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 919 +122554000: cap 0: stop receiving +122556000: cap 0: running thread 2 +122558000: cap 0: waking up thread 3 on cap 0 +122576000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +122579000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +122582000: cap 0: running thread 1 +122585000: cap 0: waking up thread 4 on cap 0 +122587000: cap 0: waking up thread 2 on cap 0 +122594000: cap 0: stopping thread 1 (blocked on an MVar) +122596000: cap 0: running thread 3 +122598000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +122600000: cap 0: running thread 2 +122602000: cap 0: waking up thread 3 on cap 0 +122605000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +122607000: cap 0: running thread 4 +122609000: cap 0: waking up thread 1 on cap 0 +122611000: cap 0: stopping thread 4 (blocked on an MVar) +122613000: cap 0: running thread 3 +122616000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +122618000: cap 0: waking up thread 6 on cap 0 +122620000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +122622000: cap 0: running thread 1 +122624000: cap 0: waking up thread 5 on cap 0 +122626000: cap 0: waking up thread 2 on cap 0 +122630000: cap 0: stopping thread 1 (blocked on an MVar) +122633000: cap 0: running thread 6 +122639000: cap 0: stopping thread 6 (heap overflow) +122641000: cap 0: starting GC +122653000: cap 0: GC working +123175000: cap 0: GC idle +123176000: cap 0: GC done +123179000: cap 0: GC idle +123180000: cap 0: GC done +123182000: cap 0: GC idle +123184000: cap 0: GC done +123186000: cap 0: GC idle +123187000: cap 0: GC done +123196000: cap 0: finished GC +123199000: cap 0: running thread 6 +125286000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +125289000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +125293000: cap 0: running thread 5 +125295000: cap 0: waking up thread 1 on cap 0 +125298000: cap 0: stopping thread 5 (blocked on an MVar) +125302000: cap 0: starting to receive +125382000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 890 +125384000: cap 0: stop receiving +125386000: cap 0: running thread 2 +125388000: cap 0: waking up thread 3 on cap 0 +125405000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +125408000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +125410000: cap 0: running thread 1 +125413000: cap 0: waking up thread 4 on cap 0 +125415000: cap 0: waking up thread 2 on cap 0 +125419000: cap 0: stopping thread 1 (blocked on an MVar) +125422000: cap 0: running thread 3 +125424000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +125426000: cap 0: running thread 2 +125428000: cap 0: waking up thread 3 on cap 0 +125430000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +125432000: cap 0: running thread 4 +125434000: cap 0: waking up thread 1 on cap 0 +125436000: cap 0: stopping thread 4 (blocked on an MVar) +125439000: cap 0: running thread 3 +125441000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +125443000: cap 0: waking up thread 6 on cap 0 +125446000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +125452000: cap 0: running thread 1 +125454000: cap 0: waking up thread 5 on cap 0 +125456000: cap 0: waking up thread 2 on cap 0 +125460000: cap 0: stopping thread 1 (blocked on an MVar) +125463000: cap 0: running thread 6 +127604000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +127607000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +127610000: cap 0: running thread 5 +127612000: cap 0: waking up thread 1 on cap 0 +127615000: cap 0: stopping thread 5 (blocked on an MVar) +127617000: cap 0: running thread 2 +127619000: cap 0: waking up thread 3 on cap 0 +127635000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +127637000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +127640000: cap 0: running thread 1 +127642000: cap 0: waking up thread 4 on cap 0 +127644000: cap 0: waking up thread 2 on cap 0 +127649000: cap 0: stopping thread 1 (blocked on an MVar) +127651000: cap 0: running thread 3 +127653000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +127655000: cap 0: running thread 2 +127657000: cap 0: waking up thread 3 on cap 0 +127659000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +127661000: cap 0: running thread 4 +127663000: cap 0: waking up thread 1 on cap 0 +127665000: cap 0: stopping thread 4 (blocked on an MVar) +127667000: cap 0: running thread 3 +127670000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +127672000: cap 0: waking up thread 6 on cap 0 +127674000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +127676000: cap 0: running thread 1 +127678000: cap 0: waking up thread 5 on cap 0 +127680000: cap 0: waking up thread 2 on cap 0 +127685000: cap 0: stopping thread 1 (blocked on an MVar) +127689000: cap 0: running thread 6 +129668000: cap 0: stopping thread 6 (thread yielding) +129676000: cap 0: starting to receive +129758000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 915 +129760000: cap 0: stop receiving +129762000: cap 0: running thread 5 +129764000: cap 0: waking up thread 1 on cap 0 +129767000: cap 0: stopping thread 5 (blocked on an MVar) +129769000: cap 0: running thread 2 +129771000: cap 0: waking up thread 3 on cap 0 +129787000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +129790000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +129793000: cap 0: running thread 1 +129795000: cap 0: waking up thread 4 on cap 0 +129797000: cap 0: waking up thread 2 on cap 0 +129801000: cap 0: stopping thread 1 (blocked on an MVar) +129804000: cap 0: running thread 6 +130035000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +130038000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +130042000: cap 0: running thread 3 +130044000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +130049000: cap 0: starting to receive +130130000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 913 +130132000: cap 0: stop receiving +130134000: cap 0: running thread 2 +130136000: cap 0: waking up thread 3 on cap 0 +130139000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +130141000: cap 0: running thread 4 +130143000: cap 0: waking up thread 1 on cap 0 +130145000: cap 0: stopping thread 4 (blocked on an MVar) +130147000: cap 0: running thread 3 +130150000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +130152000: cap 0: waking up thread 6 on cap 0 +130154000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +130157000: cap 0: running thread 1 +130159000: cap 0: waking up thread 5 on cap 0 +130161000: cap 0: waking up thread 2 on cap 0 +130166000: cap 0: stopping thread 1 (blocked on an MVar) +130169000: cap 0: running thread 6 +132345000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +132348000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +132352000: cap 0: running thread 5 +132354000: cap 0: waking up thread 1 on cap 0 +132357000: cap 0: stopping thread 5 (blocked on an MVar) +132361000: cap 0: starting to receive +132444000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 913 +132447000: cap 0: stop receiving +132449000: cap 0: running thread 2 +132451000: cap 0: waking up thread 3 on cap 0 +132466000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +132469000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +132472000: cap 0: running thread 1 +132474000: cap 0: waking up thread 4 on cap 0 +132476000: cap 0: waking up thread 2 on cap 0 +132481000: cap 0: stopping thread 1 (blocked on an MVar) +132483000: cap 0: running thread 3 +132485000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +132487000: cap 0: running thread 2 +132489000: cap 0: waking up thread 3 on cap 0 +132491000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +132494000: cap 0: running thread 4 +132495000: cap 0: waking up thread 1 on cap 0 +132498000: cap 0: stopping thread 4 (blocked on an MVar) +132500000: cap 0: running thread 3 +132502000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +132504000: cap 0: waking up thread 6 on cap 0 +132507000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +132509000: cap 0: running thread 1 +132511000: cap 0: waking up thread 5 on cap 0 +132513000: cap 0: waking up thread 2 on cap 0 +132517000: cap 0: stopping thread 1 (blocked on an MVar) +132519000: cap 0: running thread 6 +134716000: cap 0: stopping thread 6 (heap overflow) +134718000: cap 0: starting GC +134727000: cap 0: GC working +135155000: cap 0: GC idle +135157000: cap 0: GC done +135159000: cap 0: GC idle +135161000: cap 0: GC done +135163000: cap 0: GC idle +135164000: cap 0: GC done +135166000: cap 0: GC idle +135167000: cap 0: GC done +135176000: cap 0: finished GC +135181000: cap 0: running thread 6 +135217000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +135220000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +135225000: cap 0: starting to receive +135307000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 913 +135310000: cap 0: stop receiving +135312000: cap 0: running thread 5 +135314000: cap 0: waking up thread 1 on cap 0 +135316000: cap 0: stopping thread 5 (blocked on an MVar) +135318000: cap 0: running thread 2 +135320000: cap 0: waking up thread 3 on cap 0 +135337000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +135340000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +135343000: cap 0: running thread 1 +135345000: cap 0: waking up thread 4 on cap 0 +135347000: cap 0: waking up thread 2 on cap 0 +135353000: cap 0: stopping thread 1 (blocked on an MVar) +135355000: cap 0: running thread 3 +135357000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +135359000: cap 0: running thread 2 +135361000: cap 0: waking up thread 3 on cap 0 +135364000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +135366000: cap 0: running thread 4 +135368000: cap 0: waking up thread 1 on cap 0 +135370000: cap 0: stopping thread 4 (blocked on an MVar) +135372000: cap 0: running thread 3 +135375000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +135377000: cap 0: waking up thread 6 on cap 0 +135379000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +135381000: cap 0: running thread 1 +135383000: cap 0: waking up thread 5 on cap 0 +135385000: cap 0: waking up thread 2 on cap 0 +135389000: cap 0: stopping thread 1 (blocked on an MVar) +135392000: cap 0: running thread 6 +137907000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +137910000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +137914000: cap 0: running thread 5 +137916000: cap 0: waking up thread 1 on cap 0 +137918000: cap 0: stopping thread 5 (blocked on an MVar) +137922000: cap 0: starting to receive +137998000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 882 +138000000: cap 0: stop receiving +138002000: cap 0: running thread 2 +138004000: cap 0: waking up thread 3 on cap 0 +138020000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +138023000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +138025000: cap 0: running thread 1 +138028000: cap 0: waking up thread 4 on cap 0 +138030000: cap 0: waking up thread 2 on cap 0 +138034000: cap 0: stopping thread 1 (blocked on an MVar) +138036000: cap 0: running thread 3 +138038000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +138040000: cap 0: running thread 2 +138042000: cap 0: waking up thread 3 on cap 0 +138045000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +138047000: cap 0: running thread 4 +138049000: cap 0: waking up thread 1 on cap 0 +138051000: cap 0: stopping thread 4 (blocked on an MVar) +138053000: cap 0: running thread 3 +138056000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +138058000: cap 0: waking up thread 6 on cap 0 +138060000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +138062000: cap 0: running thread 1 +138064000: cap 0: waking up thread 5 on cap 0 +138066000: cap 0: waking up thread 2 on cap 0 +138070000: cap 0: stopping thread 1 (blocked on an MVar) +138072000: cap 0: running thread 6 +140718000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +140721000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +140727000: cap 0: running thread 5 +140730000: cap 0: waking up thread 1 on cap 0 +140732000: cap 0: stopping thread 5 (blocked on an MVar) +140736000: cap 0: starting to receive +140816000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 891 +140818000: cap 0: stop receiving +140820000: cap 0: running thread 2 +140822000: cap 0: waking up thread 3 on cap 0 +140838000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +140841000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +140844000: cap 0: running thread 1 +140846000: cap 0: waking up thread 4 on cap 0 +140848000: cap 0: waking up thread 2 on cap 0 +140852000: cap 0: stopping thread 1 (blocked on an MVar) +140855000: cap 0: running thread 3 +140857000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +140859000: cap 0: running thread 2 +140861000: cap 0: waking up thread 3 on cap 0 +140863000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +140865000: cap 0: running thread 4 +140867000: cap 0: waking up thread 1 on cap 0 +140869000: cap 0: stopping thread 4 (blocked on an MVar) +140871000: cap 0: running thread 3 +140874000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +140876000: cap 0: waking up thread 6 on cap 0 +140878000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +140881000: cap 0: running thread 1 +140883000: cap 0: waking up thread 5 on cap 0 +140884000: cap 0: waking up thread 2 on cap 0 +140889000: cap 0: stopping thread 1 (blocked on an MVar) +140891000: cap 0: running thread 6 +143631000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +143634000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +143638000: cap 0: running thread 5 +143640000: cap 0: waking up thread 1 on cap 0 +143642000: cap 0: stopping thread 5 (blocked on an MVar) +143646000: cap 0: starting to receive +143724000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 887 +143726000: cap 0: stop receiving +143728000: cap 0: running thread 2 +143730000: cap 0: waking up thread 3 on cap 0 +143746000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +143749000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +143751000: cap 0: running thread 1 +143754000: cap 0: waking up thread 4 on cap 0 +143756000: cap 0: waking up thread 2 on cap 0 +143760000: cap 0: stopping thread 1 (blocked on an MVar) +143762000: cap 0: running thread 3 +143764000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +143767000: cap 0: running thread 2 +143768000: cap 0: waking up thread 3 on cap 0 +143771000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +143773000: cap 0: running thread 4 +143775000: cap 0: waking up thread 1 on cap 0 +143777000: cap 0: stopping thread 4 (blocked on an MVar) +143779000: cap 0: running thread 3 +143782000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +143784000: cap 0: waking up thread 6 on cap 0 +143786000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +143788000: cap 0: running thread 1 +143790000: cap 0: waking up thread 5 on cap 0 +143792000: cap 0: waking up thread 2 on cap 0 +143796000: cap 0: stopping thread 1 (blocked on an MVar) +143799000: cap 0: running thread 6 +146578000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +146581000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +146585000: cap 0: running thread 5 +146587000: cap 0: waking up thread 1 on cap 0 +146589000: cap 0: stopping thread 5 (blocked on an MVar) +146591000: cap 0: running thread 2 +146593000: cap 0: waking up thread 3 on cap 0 +146609000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +146612000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +146616000: cap 0: running thread 1 +146618000: cap 0: waking up thread 4 on cap 0 +146620000: cap 0: waking up thread 2 on cap 0 +146625000: cap 0: stopping thread 1 (blocked on an MVar) +146630000: cap 0: starting to receive +146707000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 883 +146710000: cap 0: stop receiving +146711000: cap 0: running thread 3 +146714000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +146716000: cap 0: running thread 2 +146718000: cap 0: waking up thread 3 on cap 0 +146720000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +146727000: cap 0: running thread 4 +146729000: cap 0: waking up thread 1 on cap 0 +146731000: cap 0: stopping thread 4 (blocked on an MVar) +146733000: cap 0: running thread 3 +146736000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +146738000: cap 0: waking up thread 6 on cap 0 +146740000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +146742000: cap 0: running thread 1 +146744000: cap 0: waking up thread 5 on cap 0 +146746000: cap 0: waking up thread 2 on cap 0 +146751000: cap 0: stopping thread 1 (blocked on an MVar) +146753000: cap 0: running thread 6 +149617000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +149620000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +149623000: cap 0: running thread 5 +149624000: cap 0: waking up thread 1 on cap 0 +149627000: cap 0: stopping thread 5 (blocked on an MVar) +149630000: cap 0: running thread 2 +149632000: cap 0: waking up thread 3 on cap 0 +149648000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +149651000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +149665000: cap 0: starting to receive +149742000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 873 +149745000: cap 0: stop receiving +149746000: cap 0: running thread 1 +149749000: cap 0: waking up thread 4 on cap 0 +149751000: cap 0: waking up thread 2 on cap 0 +149755000: cap 0: stopping thread 1 (blocked on an MVar) +149758000: cap 0: running thread 3 +149760000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +149762000: cap 0: running thread 2 +149764000: cap 0: waking up thread 3 on cap 0 +149766000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +149768000: cap 0: running thread 4 +149770000: cap 0: waking up thread 1 on cap 0 +149772000: cap 0: stopping thread 4 (blocked on an MVar) +149774000: cap 0: running thread 3 +149777000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +149779000: cap 0: waking up thread 6 on cap 0 +149781000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +149784000: cap 0: running thread 1 +149786000: cap 0: stopping thread 1 (thread yielding) +149788000: cap 0: running thread 6 +152503000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +152506000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +152511000: cap 0: running thread 1 +152513000: cap 0: waking up thread 5 on cap 0 +152515000: cap 0: waking up thread 2 on cap 0 +152519000: cap 0: stopping thread 1 (blocked on an MVar) +152521000: cap 0: running thread 5 +152523000: cap 0: waking up thread 1 on cap 0 +152525000: cap 0: stopping thread 5 (blocked on an MVar) +152528000: cap 0: running thread 2 +152529000: cap 0: waking up thread 3 on cap 0 +152546000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +152549000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +152552000: cap 0: running thread 1 +152554000: cap 0: waking up thread 4 on cap 0 +152556000: cap 0: waking up thread 2 on cap 0 +152560000: cap 0: stopping thread 1 (blocked on an MVar) +152562000: cap 0: running thread 3 +152564000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +152566000: cap 0: running thread 2 +152568000: cap 0: waking up thread 3 on cap 0 +152571000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +152573000: cap 0: running thread 4 +152575000: cap 0: waking up thread 1 on cap 0 +152577000: cap 0: stopping thread 4 (blocked on an MVar) +152579000: cap 0: running thread 3 +152581000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +152583000: cap 0: waking up thread 6 on cap 0 +152585000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +152588000: cap 0: running thread 1 +152590000: cap 0: waking up thread 5 on cap 0 +152592000: cap 0: waking up thread 2 on cap 0 +152596000: cap 0: stopping thread 1 (blocked on an MVar) +152600000: cap 0: running thread 6 +152666000: cap 0: stopping thread 6 (heap overflow) +152668000: cap 0: starting GC +152677000: cap 0: GC working +153272000: cap 0: GC idle +153274000: cap 0: GC done +153276000: cap 0: GC idle +153278000: cap 0: GC done +153280000: cap 0: GC idle +153281000: cap 0: GC done +153283000: cap 0: GC idle +153285000: cap 0: GC done +153293000: cap 0: finished GC +153299000: cap 0: starting to receive +153375000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 877 +153377000: cap 0: stop receiving +153379000: cap 0: running thread 6 +155962000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +155965000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +155969000: cap 0: running thread 5 +155971000: cap 0: waking up thread 1 on cap 0 +155974000: cap 0: stopping thread 5 (blocked on an MVar) +155978000: cap 0: starting to receive +156045000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 834 +156048000: cap 0: stop receiving +156049000: cap 0: running thread 2 +156051000: cap 0: waking up thread 3 on cap 0 +156068000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +156071000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +156073000: cap 0: running thread 1 +156076000: cap 0: waking up thread 4 on cap 0 +156078000: cap 0: waking up thread 2 on cap 0 +156082000: cap 0: stopping thread 1 (blocked on an MVar) +156085000: cap 0: running thread 3 +156087000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +156089000: cap 0: running thread 2 +156091000: cap 0: waking up thread 3 on cap 0 +156093000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +156096000: cap 0: running thread 4 +156097000: cap 0: waking up thread 1 on cap 0 +156100000: cap 0: stopping thread 4 (blocked on an MVar) +156102000: cap 0: running thread 3 +156104000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +156106000: cap 0: waking up thread 6 on cap 0 +156109000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +156111000: cap 0: running thread 1 +156113000: cap 0: waking up thread 5 on cap 0 +156115000: cap 0: waking up thread 2 on cap 0 +156119000: cap 0: stopping thread 1 (blocked on an MVar) +156121000: cap 0: running thread 6 +158588000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +158591000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +158594000: cap 0: running thread 5 +158596000: cap 0: waking up thread 1 on cap 0 +158598000: cap 0: stopping thread 5 (blocked on an MVar) +158600000: cap 0: running thread 2 +158602000: cap 0: waking up thread 3 on cap 0 +158618000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +158621000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +158624000: cap 0: running thread 1 +158626000: cap 0: waking up thread 4 on cap 0 +158628000: cap 0: waking up thread 2 on cap 0 +158632000: cap 0: stopping thread 1 (blocked on an MVar) +158635000: cap 0: running thread 3 +158637000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +158639000: cap 0: running thread 2 +158641000: cap 0: waking up thread 3 on cap 0 +158643000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +158645000: cap 0: running thread 4 +158647000: cap 0: waking up thread 1 on cap 0 +158649000: cap 0: stopping thread 4 (blocked on an MVar) +158651000: cap 0: running thread 3 +158654000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +158656000: cap 0: waking up thread 6 on cap 0 +158658000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +158660000: cap 0: running thread 1 +158662000: cap 0: waking up thread 5 on cap 0 +158664000: cap 0: waking up thread 2 on cap 0 +158668000: cap 0: stopping thread 1 (blocked on an MVar) +158671000: cap 0: running thread 6 +160886000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +160889000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +160893000: cap 0: running thread 5 +160895000: cap 0: waking up thread 1 on cap 0 +160897000: cap 0: stopping thread 5 (blocked on an MVar) +160901000: cap 0: starting to receive +160981000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 891 +160984000: cap 0: stop receiving +160985000: cap 0: running thread 2 +160987000: cap 0: waking up thread 3 on cap 0 +161004000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +161006000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +161009000: cap 0: running thread 1 +161011000: cap 0: waking up thread 4 on cap 0 +161013000: cap 0: waking up thread 2 on cap 0 +161018000: cap 0: stopping thread 1 (blocked on an MVar) +161020000: cap 0: running thread 3 +161022000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +161024000: cap 0: running thread 2 +161026000: cap 0: waking up thread 3 on cap 0 +161029000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +161031000: cap 0: running thread 4 +161032000: cap 0: waking up thread 1 on cap 0 +161035000: cap 0: stopping thread 4 (blocked on an MVar) +161037000: cap 0: running thread 3 +161039000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +161041000: cap 0: waking up thread 6 on cap 0 +161043000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +161046000: cap 0: running thread 1 +161048000: cap 0: waking up thread 5 on cap 0 +161050000: cap 0: waking up thread 2 on cap 0 +161054000: cap 0: stopping thread 1 (blocked on an MVar) +161056000: cap 0: running thread 6 +163291000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +163294000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +163299000: cap 0: running thread 5 +163301000: cap 0: waking up thread 1 on cap 0 +163304000: cap 0: stopping thread 5 (blocked on an MVar) +163308000: cap 0: starting to receive +163389000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 907 +163391000: cap 0: stop receiving +163393000: cap 0: running thread 2 +163395000: cap 0: waking up thread 3 on cap 0 +163411000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +163414000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +163416000: cap 0: running thread 1 +163418000: cap 0: waking up thread 4 on cap 0 +163420000: cap 0: waking up thread 2 on cap 0 +163425000: cap 0: stopping thread 1 (blocked on an MVar) +163427000: cap 0: running thread 3 +163429000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +163431000: cap 0: running thread 2 +163433000: cap 0: waking up thread 3 on cap 0 +163436000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +163438000: cap 0: running thread 4 +163440000: cap 0: waking up thread 1 on cap 0 +163442000: cap 0: stopping thread 4 (blocked on an MVar) +163444000: cap 0: running thread 3 +163447000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +163449000: cap 0: waking up thread 6 on cap 0 +163451000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +163453000: cap 0: running thread 1 +163455000: cap 0: waking up thread 5 on cap 0 +163457000: cap 0: waking up thread 2 on cap 0 +163461000: cap 0: stopping thread 1 (blocked on an MVar) +163463000: cap 0: running thread 6 +165614000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +165617000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +165621000: cap 0: running thread 5 +165623000: cap 0: waking up thread 1 on cap 0 +165625000: cap 0: stopping thread 5 (blocked on an MVar) +165629000: cap 0: starting to receive +165712000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 913 +165714000: cap 0: stop receiving +165716000: cap 0: running thread 2 +165718000: cap 0: waking up thread 3 on cap 0 +165734000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +165736000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +165739000: cap 0: running thread 1 +165741000: cap 0: waking up thread 4 on cap 0 +165743000: cap 0: waking up thread 2 on cap 0 +165748000: cap 0: stopping thread 1 (blocked on an MVar) +165750000: cap 0: running thread 3 +165752000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +165754000: cap 0: running thread 2 +165756000: cap 0: waking up thread 3 on cap 0 +165759000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +165761000: cap 0: running thread 4 +165762000: cap 0: waking up thread 1 on cap 0 +165765000: cap 0: stopping thread 4 (blocked on an MVar) +165767000: cap 0: running thread 3 +165769000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +165771000: cap 0: waking up thread 6 on cap 0 +165774000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +165776000: cap 0: running thread 1 +165778000: cap 0: waking up thread 5 on cap 0 +165780000: cap 0: waking up thread 2 on cap 0 +165784000: cap 0: stopping thread 1 (blocked on an MVar) +165786000: cap 0: running thread 6 +167843000: cap 0: stopping thread 6 (heap overflow) +167845000: cap 0: starting GC +167853000: cap 0: GC working +168381000: cap 0: GC idle +168383000: cap 0: GC done +168385000: cap 0: GC idle +168387000: cap 0: GC done +168388000: cap 0: GC idle +168390000: cap 0: GC done +168392000: cap 0: GC idle +168393000: cap 0: GC done +168402000: cap 0: finished GC +168407000: cap 0: running thread 6 +168487000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +168490000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +168497000: cap 0: starting to receive +168580000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 913 +168661000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 911 +168664000: cap 0: stop receiving +168666000: cap 0: running thread 5 +168672000: cap 0: waking up thread 1 on cap 0 +168674000: cap 0: stopping thread 5 (blocked on an MVar) +168677000: cap 0: running thread 2 +168679000: cap 0: waking up thread 3 on cap 0 +168695000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +168698000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +168701000: cap 0: running thread 1 +168703000: cap 0: waking up thread 4 on cap 0 +168705000: cap 0: waking up thread 2 on cap 0 +168710000: cap 0: stopping thread 1 (blocked on an MVar) +168712000: cap 0: running thread 3 +168714000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +168716000: cap 0: running thread 2 +168718000: cap 0: waking up thread 3 on cap 0 +168721000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +168723000: cap 0: running thread 4 +168725000: cap 0: waking up thread 1 on cap 0 +168727000: cap 0: stopping thread 4 (blocked on an MVar) +168729000: cap 0: running thread 3 +168732000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +168734000: cap 0: waking up thread 6 on cap 0 +168736000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +168738000: cap 0: running thread 1 +168740000: cap 0: waking up thread 5 on cap 0 +168742000: cap 0: waking up thread 2 on cap 0 +168746000: cap 0: stopping thread 1 (blocked on an MVar) +168749000: cap 0: running thread 6 +169680000: cap 0: stopping thread 6 (thread yielding) +169683000: cap 0: running thread 5 +169685000: cap 0: waking up thread 1 on cap 0 +169687000: cap 0: stopping thread 5 (blocked on an MVar) +169690000: cap 0: running thread 2 +169691000: cap 0: waking up thread 3 on cap 0 +169708000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +169711000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +169713000: cap 0: running thread 1 +169715000: cap 0: waking up thread 4 on cap 0 +169717000: cap 0: waking up thread 2 on cap 0 +169722000: cap 0: stopping thread 1 (blocked on an MVar) +169724000: cap 0: running thread 6 +170913000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +170916000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +170919000: cap 0: running thread 3 +170921000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +170924000: cap 0: running thread 2 +170925000: cap 0: waking up thread 3 on cap 0 +170928000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +170930000: cap 0: running thread 4 +170932000: cap 0: waking up thread 1 on cap 0 +170934000: cap 0: stopping thread 4 (blocked on an MVar) +170936000: cap 0: running thread 3 +170939000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +170941000: cap 0: waking up thread 6 on cap 0 +170943000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +170945000: cap 0: running thread 1 +170947000: cap 0: waking up thread 5 on cap 0 +170949000: cap 0: waking up thread 2 on cap 0 +170954000: cap 0: stopping thread 1 (blocked on an MVar) +170956000: cap 0: running thread 6 +173103000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +173106000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +173109000: cap 0: running thread 5 +173111000: cap 0: waking up thread 1 on cap 0 +173113000: cap 0: stopping thread 5 (blocked on an MVar) +173118000: cap 0: starting to receive +173195000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 892 +173198000: cap 0: stop receiving +173200000: cap 0: running thread 2 +173201000: cap 0: waking up thread 3 on cap 0 +173218000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +173221000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +173223000: cap 0: running thread 1 +173226000: cap 0: waking up thread 4 on cap 0 +173228000: cap 0: waking up thread 2 on cap 0 +173232000: cap 0: stopping thread 1 (blocked on an MVar) +173234000: cap 0: running thread 3 +173236000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +173239000: cap 0: running thread 2 +173240000: cap 0: waking up thread 3 on cap 0 +173243000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +173245000: cap 0: running thread 4 +173247000: cap 0: waking up thread 1 on cap 0 +173249000: cap 0: stopping thread 4 (blocked on an MVar) +173251000: cap 0: running thread 3 +173253000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +173255000: cap 0: waking up thread 6 on cap 0 +173258000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +173261000: cap 0: running thread 1 +173263000: cap 0: waking up thread 5 on cap 0 +173265000: cap 0: waking up thread 2 on cap 0 +173270000: cap 0: stopping thread 1 (blocked on an MVar) +173274000: cap 0: starting to receive +173359000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 917 +173363000: cap 0: stop receiving +173365000: cap 0: running thread 6 +175425000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +175428000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +175431000: cap 0: running thread 5 +175433000: cap 0: waking up thread 1 on cap 0 +175436000: cap 0: stopping thread 5 (blocked on an MVar) +175438000: cap 0: running thread 2 +175440000: cap 0: waking up thread 3 on cap 0 +175456000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +175459000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +175461000: cap 0: running thread 1 +175463000: cap 0: waking up thread 4 on cap 0 +175465000: cap 0: waking up thread 2 on cap 0 +175470000: cap 0: stopping thread 1 (blocked on an MVar) +175472000: cap 0: running thread 3 +175474000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +175476000: cap 0: running thread 2 +175478000: cap 0: waking up thread 3 on cap 0 +175481000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +175483000: cap 0: running thread 4 +175485000: cap 0: waking up thread 1 on cap 0 +175487000: cap 0: stopping thread 4 (blocked on an MVar) +175489000: cap 0: running thread 3 +175491000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +175493000: cap 0: waking up thread 6 on cap 0 +175495000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +175498000: cap 0: running thread 1 +175500000: cap 0: waking up thread 5 on cap 0 +175502000: cap 0: waking up thread 2 on cap 0 +175506000: cap 0: stopping thread 1 (blocked on an MVar) +175508000: cap 0: running thread 6 +177473000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +177475000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +177479000: cap 0: running thread 5 +177481000: cap 0: waking up thread 1 on cap 0 +177483000: cap 0: stopping thread 5 (blocked on an MVar) +177488000: cap 0: starting to receive +177570000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 913 +177573000: cap 0: stop receiving +177574000: cap 0: running thread 2 +177576000: cap 0: waking up thread 3 on cap 0 +177592000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +177595000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +177598000: cap 0: running thread 1 +177600000: cap 0: waking up thread 4 on cap 0 +177602000: cap 0: waking up thread 2 on cap 0 +177606000: cap 0: stopping thread 1 (blocked on an MVar) +177609000: cap 0: running thread 3 +177611000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +177613000: cap 0: running thread 2 +177615000: cap 0: waking up thread 3 on cap 0 +177617000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +177619000: cap 0: running thread 4 +177621000: cap 0: waking up thread 1 on cap 0 +177623000: cap 0: stopping thread 4 (blocked on an MVar) +177625000: cap 0: running thread 3 +177628000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +177630000: cap 0: waking up thread 6 on cap 0 +177632000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +177634000: cap 0: running thread 1 +177636000: cap 0: waking up thread 5 on cap 0 +177638000: cap 0: waking up thread 2 on cap 0 +177642000: cap 0: stopping thread 1 (blocked on an MVar) +177645000: cap 0: running thread 6 +177741000: cap 0: stopping thread 6 (heap overflow) +177743000: cap 0: starting GC +177752000: cap 0: GC working +178217000: cap 0: GC idle +178218000: cap 0: GC done +178220000: cap 0: GC idle +178222000: cap 0: GC done +178224000: cap 0: GC idle +178225000: cap 0: GC done +178227000: cap 0: GC idle +178229000: cap 0: GC done +178238000: cap 0: finished GC +178242000: cap 0: running thread 6 +180097000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +180100000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +180107000: cap 0: starting to receive +180191000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 921 +180274000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 923 +180277000: cap 0: stop receiving +180279000: cap 0: running thread 5 +180281000: cap 0: waking up thread 1 on cap 0 +180283000: cap 0: stopping thread 5 (blocked on an MVar) +180286000: cap 0: running thread 2 +180288000: cap 0: waking up thread 3 on cap 0 +180304000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +180308000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +180310000: cap 0: running thread 1 +180313000: cap 0: waking up thread 4 on cap 0 +180315000: cap 0: waking up thread 2 on cap 0 +180319000: cap 0: stopping thread 1 (blocked on an MVar) +180322000: cap 0: running thread 3 +180324000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +180326000: cap 0: running thread 2 +180328000: cap 0: waking up thread 3 on cap 0 +180330000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +180332000: cap 0: running thread 4 +180334000: cap 0: waking up thread 1 on cap 0 +180336000: cap 0: stopping thread 4 (blocked on an MVar) +180338000: cap 0: running thread 3 +180341000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +180343000: cap 0: waking up thread 6 on cap 0 +180345000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +180348000: cap 0: running thread 1 +180350000: cap 0: waking up thread 5 on cap 0 +180352000: cap 0: waking up thread 2 on cap 0 +180356000: cap 0: stopping thread 1 (blocked on an MVar) +180358000: cap 0: running thread 6 +182226000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +182229000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +182232000: cap 0: running thread 5 +182234000: cap 0: waking up thread 1 on cap 0 +182236000: cap 0: stopping thread 5 (blocked on an MVar) +182238000: cap 0: running thread 2 +182240000: cap 0: waking up thread 3 on cap 0 +182256000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +182258000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +182261000: cap 0: running thread 1 +182263000: cap 0: waking up thread 4 on cap 0 +182265000: cap 0: waking up thread 2 on cap 0 +182270000: cap 0: stopping thread 1 (blocked on an MVar) +182272000: cap 0: running thread 3 +182274000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +182276000: cap 0: running thread 2 +182278000: cap 0: waking up thread 3 on cap 0 +182280000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +182282000: cap 0: running thread 4 +182284000: cap 0: waking up thread 1 on cap 0 +182286000: cap 0: stopping thread 4 (blocked on an MVar) +182289000: cap 0: running thread 3 +182291000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +182293000: cap 0: waking up thread 6 on cap 0 +182295000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +182298000: cap 0: running thread 1 +182300000: cap 0: waking up thread 5 on cap 0 +182302000: cap 0: waking up thread 2 on cap 0 +182306000: cap 0: stopping thread 1 (blocked on an MVar) +182308000: cap 0: running thread 6 +184211000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +184218000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +184224000: cap 0: running thread 5 +184226000: cap 0: waking up thread 1 on cap 0 +184228000: cap 0: stopping thread 5 (blocked on an MVar) +184233000: cap 0: starting to receive +184311000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 891 +184314000: cap 0: stop receiving +184315000: cap 0: running thread 2 +184317000: cap 0: waking up thread 3 on cap 0 +184333000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +184336000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +184339000: cap 0: running thread 1 +184341000: cap 0: waking up thread 4 on cap 0 +184343000: cap 0: waking up thread 2 on cap 0 +184348000: cap 0: stopping thread 1 (blocked on an MVar) +184350000: cap 0: running thread 3 +184352000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +184354000: cap 0: running thread 2 +184356000: cap 0: waking up thread 3 on cap 0 +184358000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +184361000: cap 0: running thread 4 +184362000: cap 0: waking up thread 1 on cap 0 +184364000: cap 0: stopping thread 4 (blocked on an MVar) +184367000: cap 0: running thread 3 +184369000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +184371000: cap 0: waking up thread 6 on cap 0 +184373000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +184376000: cap 0: running thread 1 +184378000: cap 0: waking up thread 5 on cap 0 +184380000: cap 0: waking up thread 2 on cap 0 +184384000: cap 0: stopping thread 1 (blocked on an MVar) +184386000: cap 0: running thread 6 +186361000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +186372000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +186376000: cap 0: running thread 5 +186378000: cap 0: waking up thread 1 on cap 0 +186384000: cap 0: stopping thread 5 (blocked on an MVar) +186389000: cap 0: starting to receive +186472000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 931 +186475000: cap 0: stop receiving +186477000: cap 0: running thread 2 +186478000: cap 0: waking up thread 3 on cap 0 +186495000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +186498000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +186500000: cap 0: running thread 1 +186503000: cap 0: waking up thread 4 on cap 0 +186505000: cap 0: waking up thread 2 on cap 0 +186509000: cap 0: stopping thread 1 (blocked on an MVar) +186511000: cap 0: running thread 3 +186513000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +186516000: cap 0: running thread 2 +186517000: cap 0: waking up thread 3 on cap 0 +186520000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +186522000: cap 0: running thread 4 +186524000: cap 0: waking up thread 1 on cap 0 +186526000: cap 0: stopping thread 4 (blocked on an MVar) +186528000: cap 0: running thread 3 +186530000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +186533000: cap 0: waking up thread 6 on cap 0 +186535000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +186537000: cap 0: running thread 1 +186539000: cap 0: waking up thread 5 on cap 0 +186542000: cap 0: waking up thread 2 on cap 0 +186546000: cap 0: stopping thread 1 (blocked on an MVar) +186550000: cap 0: running thread 6 +188456000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +188459000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +188463000: cap 0: starting to receive +188548000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 924 +188550000: cap 0: stop receiving +188552000: cap 0: running thread 5 +188554000: cap 0: waking up thread 1 on cap 0 +188556000: cap 0: stopping thread 5 (blocked on an MVar) +188559000: cap 0: running thread 2 +188560000: cap 0: waking up thread 3 on cap 0 +188577000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +188580000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +188582000: cap 0: running thread 1 +188585000: cap 0: waking up thread 4 on cap 0 +188587000: cap 0: waking up thread 2 on cap 0 +188591000: cap 0: stopping thread 1 (blocked on an MVar) +188593000: cap 0: running thread 3 +188595000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +188598000: cap 0: running thread 2 +188599000: cap 0: waking up thread 3 on cap 0 +188602000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +188604000: cap 0: running thread 4 +188606000: cap 0: waking up thread 1 on cap 0 +188608000: cap 0: stopping thread 4 (blocked on an MVar) +188610000: cap 0: running thread 3 +188612000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +188614000: cap 0: waking up thread 6 on cap 0 +188617000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +188619000: cap 0: running thread 1 +188621000: cap 0: waking up thread 5 on cap 0 +188623000: cap 0: waking up thread 2 on cap 0 +188627000: cap 0: stopping thread 1 (blocked on an MVar) +188629000: cap 0: running thread 6 +188683000: cap 0: stopping thread 6 (heap overflow) +188685000: cap 0: starting GC +188694000: cap 0: GC working +189175000: cap 0: GC idle +189177000: cap 0: GC done +189179000: cap 0: GC idle +189181000: cap 0: GC done +189183000: cap 0: GC idle +189184000: cap 0: GC done +189186000: cap 0: GC idle +189188000: cap 0: GC done +189196000: cap 0: finished GC +189201000: cap 0: running thread 6 +189664000: cap 0: stopping thread 6 (thread yielding) +189669000: cap 0: starting to receive +189754000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 924 +189757000: cap 0: stop receiving +189758000: cap 0: running thread 5 +189760000: cap 0: waking up thread 1 on cap 0 +189763000: cap 0: stopping thread 5 (blocked on an MVar) +189765000: cap 0: running thread 2 +189767000: cap 0: waking up thread 3 on cap 0 +189784000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +189787000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +189789000: cap 0: running thread 1 +189792000: cap 0: waking up thread 4 on cap 0 +189794000: cap 0: waking up thread 2 on cap 0 +189798000: cap 0: stopping thread 1 (blocked on an MVar) +189800000: cap 0: running thread 6 +190980000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +190983000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +190987000: cap 0: running thread 3 +190990000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +190994000: cap 0: starting to receive +191081000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 936 +191084000: cap 0: stop receiving +191086000: cap 0: running thread 2 +191088000: cap 0: waking up thread 3 on cap 0 +191090000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +191093000: cap 0: running thread 4 +191095000: cap 0: waking up thread 1 on cap 0 +191097000: cap 0: stopping thread 4 (blocked on an MVar) +191099000: cap 0: running thread 3 +191102000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +191104000: cap 0: waking up thread 6 on cap 0 +191106000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +191108000: cap 0: running thread 1 +191111000: cap 0: waking up thread 5 on cap 0 +191112000: cap 0: waking up thread 2 on cap 0 +191117000: cap 0: stopping thread 1 (blocked on an MVar) +191119000: cap 0: running thread 6 +192406000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +192409000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +192413000: cap 0: running thread 5 +192415000: cap 0: waking up thread 1 on cap 0 +192417000: cap 0: stopping thread 5 (blocked on an MVar) +192422000: cap 0: starting to receive +192504000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 921 +192507000: cap 0: stop receiving +192508000: cap 0: running thread 2 +192510000: cap 0: waking up thread 3 on cap 0 +192526000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +192529000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +192532000: cap 0: running thread 1 +192534000: cap 0: waking up thread 4 on cap 0 +192536000: cap 0: waking up thread 2 on cap 0 +192540000: cap 0: stopping thread 1 (blocked on an MVar) +192543000: cap 0: running thread 3 +192545000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +192547000: cap 0: running thread 2 +192549000: cap 0: waking up thread 3 on cap 0 +192551000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +192554000: cap 0: running thread 4 +192556000: cap 0: waking up thread 1 on cap 0 +192558000: cap 0: stopping thread 4 (blocked on an MVar) +192560000: cap 0: running thread 3 +192562000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +192564000: cap 0: waking up thread 6 on cap 0 +192567000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +192569000: cap 0: running thread 1 +192571000: cap 0: waking up thread 5 on cap 0 +192573000: cap 0: waking up thread 2 on cap 0 +192577000: cap 0: stopping thread 1 (blocked on an MVar) +192579000: cap 0: running thread 6 +193583000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +193586000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +193588000: cap 0: running thread 5 +193590000: cap 0: waking up thread 1 on cap 0 +193593000: cap 0: stopping thread 5 (blocked on an MVar) +193595000: cap 0: running thread 2 +193597000: cap 0: waking up thread 3 on cap 0 +193613000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +193616000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +193618000: cap 0: running thread 1 +193621000: cap 0: waking up thread 4 on cap 0 +193623000: cap 0: waking up thread 2 on cap 0 +193627000: cap 0: stopping thread 1 (blocked on an MVar) +193629000: cap 0: running thread 3 +193631000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +193633000: cap 0: running thread 2 +193635000: cap 0: waking up thread 3 on cap 0 +193638000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +193640000: cap 0: running thread 4 +193642000: cap 0: waking up thread 1 on cap 0 +193644000: cap 0: stopping thread 4 (blocked on an MVar) +193646000: cap 0: running thread 3 +193648000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +193650000: cap 0: waking up thread 6 on cap 0 +193652000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +193655000: cap 0: running thread 1 +193657000: cap 0: waking up thread 5 on cap 0 +193659000: cap 0: waking up thread 2 on cap 0 +193663000: cap 0: stopping thread 1 (blocked on an MVar) +193665000: cap 0: running thread 6 +194176000: cap 0: stopping thread 6 (heap overflow) +194178000: cap 0: starting GC +194187000: cap 0: GC working +194530000: cap 0: GC idle +194531000: cap 0: GC done +194533000: cap 0: GC idle +194535000: cap 0: GC done +194537000: cap 0: GC idle +194538000: cap 0: GC done +194540000: cap 0: GC idle +194542000: cap 0: GC done +194551000: cap 0: finished GC +194557000: cap 0: running thread 6 +194634000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +194637000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +194643000: cap 0: starting to receive +194737000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 972 +194740000: cap 0: stop receiving +194742000: cap 0: running thread 5 +194744000: cap 0: waking up thread 1 on cap 0 +194746000: cap 0: stopping thread 5 (blocked on an MVar) +194748000: cap 0: running thread 2 +194750000: cap 0: waking up thread 3 on cap 0 +194768000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +194771000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +194773000: cap 0: running thread 1 +194775000: cap 0: waking up thread 4 on cap 0 +194777000: cap 0: waking up thread 2 on cap 0 +194782000: cap 0: stopping thread 1 (blocked on an MVar) +194784000: cap 0: running thread 3 +194786000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +194789000: cap 0: running thread 2 +194790000: cap 0: waking up thread 3 on cap 0 +194793000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +194797000: cap 0: running thread 4 +194798000: cap 0: waking up thread 1 on cap 0 +194801000: cap 0: stopping thread 4 (blocked on an MVar) +194805000: cap 0: starting to receive +194902000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 990 +194905000: cap 0: stop receiving +194907000: cap 0: running thread 3 +194909000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +194911000: cap 0: waking up thread 6 on cap 0 +194914000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +194916000: cap 0: running thread 1 +194918000: cap 0: waking up thread 5 on cap 0 +194920000: cap 0: waking up thread 2 on cap 0 +194925000: cap 0: stopping thread 1 (blocked on an MVar) +194927000: cap 0: running thread 6 +195309000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +195312000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +195315000: cap 0: running thread 5 +195317000: cap 0: waking up thread 1 on cap 0 +195319000: cap 0: stopping thread 5 (blocked on an MVar) +195321000: cap 0: running thread 2 +195323000: cap 0: waking up thread 3 on cap 0 +195339000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +195342000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +195344000: cap 0: running thread 1 +195347000: cap 0: waking up thread 4 on cap 0 +195349000: cap 0: waking up thread 2 on cap 0 +195353000: cap 0: stopping thread 1 (blocked on an MVar) +195355000: cap 0: running thread 3 +195358000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +195360000: cap 0: running thread 2 +195362000: cap 0: waking up thread 3 on cap 0 +195364000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +195366000: cap 0: running thread 4 +195368000: cap 0: waking up thread 1 on cap 0 +195370000: cap 0: stopping thread 4 (blocked on an MVar) +195372000: cap 0: running thread 3 +195375000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +195377000: cap 0: waking up thread 6 on cap 0 +195379000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +195381000: cap 0: running thread 1 +195383000: cap 0: waking up thread 5 on cap 0 +195385000: cap 0: waking up thread 2 on cap 0 +195389000: cap 0: stopping thread 1 (blocked on an MVar) +195392000: cap 0: running thread 6 +195727000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +195730000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +195734000: cap 0: running thread 5 +195736000: cap 0: waking up thread 1 on cap 0 +195738000: cap 0: stopping thread 5 (blocked on an MVar) +195742000: cap 0: starting to receive +195822000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 895 +195825000: cap 0: stop receiving +195826000: cap 0: running thread 2 +195828000: cap 0: waking up thread 3 on cap 0 +195845000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +195848000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +195850000: cap 0: running thread 1 +195853000: cap 0: waking up thread 4 on cap 0 +195855000: cap 0: waking up thread 2 on cap 0 +195859000: cap 0: stopping thread 1 (blocked on an MVar) +195861000: cap 0: running thread 3 +195863000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +195865000: cap 0: running thread 2 +195867000: cap 0: waking up thread 3 on cap 0 +195874000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +195876000: cap 0: running thread 4 +195878000: cap 0: waking up thread 1 on cap 0 +195880000: cap 0: stopping thread 4 (blocked on an MVar) +195882000: cap 0: running thread 3 +195885000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +195887000: cap 0: waking up thread 6 on cap 0 +195889000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +195891000: cap 0: running thread 1 +195893000: cap 0: waking up thread 5 on cap 0 +195895000: cap 0: waking up thread 2 on cap 0 +195900000: cap 0: stopping thread 1 (blocked on an MVar) +195902000: cap 0: running thread 6 +196140000: cap 0: stopping thread 6 (heap overflow) +196142000: cap 0: starting GC +196151000: cap 0: GC working +196479000: cap 0: GC idle +196480000: cap 0: GC done +196483000: cap 0: GC idle +196484000: cap 0: GC done +196486000: cap 0: GC idle +196487000: cap 0: GC done +196489000: cap 0: GC idle +196491000: cap 0: GC done +196499000: cap 0: finished GC +196504000: cap 0: running thread 6 +196591000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +196594000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +196602000: cap 0: starting to receive +196705000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 +196808000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 1014 +196811000: cap 0: stop receiving +196813000: cap 0: running thread 5 +196815000: cap 0: waking up thread 1 on cap 0 +196817000: cap 0: stopping thread 5 (blocked on an MVar) +196819000: cap 0: running thread 2 +196821000: cap 0: waking up thread 3 on cap 0 +196838000: sending message with tag Head from process 1, thread 2 to machine 2, process 1 on inport 1 +196841000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +196844000: cap 0: running thread 1 +196846000: cap 0: waking up thread 4 on cap 0 +196848000: cap 0: waking up thread 2 on cap 0 +196852000: cap 0: stopping thread 1 (blocked on an MVar) +196855000: cap 0: running thread 3 +196857000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +196859000: cap 0: running thread 2 +196861000: cap 0: waking up thread 3 on cap 0 +196864000: cap 0: stopping thread 2 (blocked on black hole owned by thread 1) +196866000: cap 0: running thread 4 +196868000: cap 0: waking up thread 1 on cap 0 +196870000: cap 0: stopping thread 4 (blocked on an MVar) +196872000: cap 0: running thread 3 +196875000: sending/receiving message with tag Head from process 1, thread 3 to process 2 on inport 5 +196877000: cap 0: waking up thread 6 on cap 0 +196879000: cap 0: stopping thread 3 (blocked on black hole owned by thread 2) +196881000: cap 0: running thread 1 +196883000: cap 0: waking up thread 5 on cap 0 +196885000: cap 0: waking up thread 2 on cap 0 +196889000: cap 0: stopping thread 1 (blocked on an MVar) +196892000: cap 0: running thread 6 +197641000: sending/receiving message with tag Head from process 2, thread 6 to process 1 on inport 3 +197644000: cap 0: stopping thread 6 (blocked on black hole owned by thread 1) +197647000: cap 0: running thread 5 +197649000: cap 0: waking up thread 1 on cap 0 +197651000: cap 0: stopping thread 5 (blocked on an MVar) +197654000: cap 0: running thread 2 +197656000: cap 0: waking up thread 3 on cap 0 +197669000: sending message with tag DataMes from process 1, thread 2 to machine 2, process 1 on inport 1 +197671000: cap 0: stopping thread 2 (thread finished) +197674000: cap 0: running thread 1 +197676000: cap 0: waking up thread 4 on cap 0 +197681000: cap 0: stopping thread 1 (blocked on an MVar) +197683000: cap 0: running thread 3 +197686000: sending/receiving message with tag DataMes from process 1, thread 3 to process 2 on inport 5 +197688000: cap 0: waking up thread 6 on cap 0 +197690000: cap 0: stopping thread 3 (thread finished) +197692000: cap 0: running thread 4 +197694000: cap 0: waking up thread 1 on cap 0 +197696000: cap 0: stopping thread 4 (blocked on an MVar) +197698000: cap 0: running thread 6 +197701000: sending/receiving message with tag DataMes from process 2, thread 6 to process 1 on inport 3 +197703000: cap 0: stopping thread 6 (thread finished) +197705000: killing process 2 +197707000: cap 0: running thread 1 +197709000: cap 0: waking up thread 5 on cap 0 +197713000: cap 0: stopping thread 1 (blocked on an MVar) +197716000: cap 0: running thread 5 +197717000: cap 0: waking up thread 1 on cap 0 +197719000: cap 0: stopping thread 5 (blocked on an MVar) +197721000: cap 0: running thread 1 +197723000: cap 0: waking up thread 4 on cap 0 +197727000: cap 0: stopping thread 1 (blocked on an MVar) +197730000: cap 0: running thread 4 +197731000: cap 0: waking up thread 1 on cap 0 +197733000: cap 0: stopping thread 4 (blocked on an MVar) +197736000: cap 0: running thread 1 +197737000: cap 0: waking up thread 5 on cap 0 +197741000: cap 0: stopping thread 1 (blocked on an MVar) +197744000: cap 0: running thread 5 +197745000: cap 0: waking up thread 1 on cap 0 +197747000: cap 0: stopping thread 5 (blocked on an MVar) +197749000: cap 0: running thread 1 +197751000: cap 0: waking up thread 4 on cap 0 +197755000: cap 0: stopping thread 1 (blocked on an MVar) +197757000: cap 0: running thread 4 +197759000: cap 0: waking up thread 1 on cap 0 +197761000: cap 0: stopping thread 4 (blocked on an MVar) +197763000: cap 0: running thread 1 +197765000: cap 0: waking up thread 5 on cap 0 +197769000: cap 0: stopping thread 1 (blocked on an MVar) +197771000: cap 0: running thread 5 +197773000: cap 0: waking up thread 1 on cap 0 +197775000: cap 0: stopping thread 5 (blocked on an MVar) +197777000: cap 0: running thread 1 +197779000: cap 0: waking up thread 4 on cap 0 +197783000: cap 0: stopping thread 1 (blocked on an MVar) +197785000: cap 0: running thread 4 +197787000: cap 0: waking up thread 1 on cap 0 +197789000: cap 0: stopping thread 4 (blocked on an MVar) +197792000: cap 0: running thread 1 +197794000: cap 0: waking up thread 5 on cap 0 +197799000: cap 0: stopping thread 1 (blocked on an MVar) +197803000: cap 0: starting to receive +197883000: cap 0: receiving message with tag Head at process 1, inport 1 from machine 2, process 1, thread 1 with size 895 +197886000: cap 0: stop receiving +197888000: cap 0: running thread 5 +197890000: cap 0: waking up thread 1 on cap 0 +197892000: cap 0: stopping thread 5 (blocked on an MVar) +197895000: cap 0: starting to receive +197907000: cap 0: receiving message with tag DataMes at process 1, inport 1 from machine 2, process 1, thread 1 with size 2 +197909000: cap 0: stop receiving +197911000: cap 0: running thread 1 +197913000: cap 0: waking up thread 4 on cap 0 +197917000: cap 0: stopping thread 1 (blocked on an MVar) +197919000: cap 0: running thread 4 +197921000: cap 0: waking up thread 1 on cap 0 +197923000: cap 0: stopping thread 4 (blocked on an MVar) +197925000: cap 0: running thread 1 +197927000: cap 0: waking up thread 5 on cap 0 +197931000: cap 0: stopping thread 1 (blocked on an MVar) +197934000: cap 0: running thread 5 +197935000: cap 0: waking up thread 1 on cap 0 +197937000: cap 0: stopping thread 5 (blocked on an MVar) +197939000: cap 0: running thread 1 +197941000: cap 0: waking up thread 4 on cap 0 +197945000: cap 0: stopping thread 1 (blocked on an MVar) +197948000: cap 0: running thread 4 +197949000: cap 0: waking up thread 1 on cap 0 +197951000: cap 0: stopping thread 4 (blocked on an MVar) +197954000: cap 0: running thread 1 +197955000: cap 0: waking up thread 5 on cap 0 +197959000: cap 0: stopping thread 1 (blocked on an MVar) +197962000: cap 0: running thread 5 +197963000: cap 0: waking up thread 1 on cap 0 +197965000: cap 0: stopping thread 5 (blocked on an MVar) +197967000: cap 0: running thread 1 +197969000: cap 0: waking up thread 4 on cap 0 +197973000: cap 0: stopping thread 1 (blocked on an MVar) +197976000: cap 0: running thread 4 +197977000: cap 0: waking up thread 1 on cap 0 +197979000: cap 0: stopping thread 4 (blocked on an MVar) +197981000: cap 0: running thread 1 +197983000: cap 0: waking up thread 5 on cap 0 +197987000: cap 0: stopping thread 1 (blocked on an MVar) +197989000: cap 0: running thread 5 +197991000: cap 0: waking up thread 1 on cap 0 +197993000: cap 0: stopping thread 5 (blocked on an MVar) +197995000: cap 0: running thread 1 +197997000: cap 0: waking up thread 4 on cap 0 +198001000: cap 0: stopping thread 1 (blocked on an MVar) +198003000: cap 0: running thread 4 +198005000: cap 0: waking up thread 1 on cap 0 +198007000: cap 0: stopping thread 4 (blocked on an MVar) +198009000: cap 0: running thread 1 +198011000: cap 0: waking up thread 5 on cap 0 +198015000: cap 0: stopping thread 1 (blocked on an MVar) +198017000: cap 0: running thread 5 +198019000: cap 0: waking up thread 1 on cap 0 +198021000: cap 0: stopping thread 5 (blocked on an MVar) +198023000: cap 0: running thread 1 +198025000: cap 0: waking up thread 4 on cap 0 +198030000: cap 0: stopping thread 1 (blocked on an MVar) +198032000: cap 0: running thread 4 +198034000: cap 0: waking up thread 1 on cap 0 +198036000: cap 0: stopping thread 4 (thread finished) +198039000: cap 0: running thread 1 +198040000: cap 0: waking up thread 5 on cap 0 +198045000: cap 0: stopping thread 1 (blocked on an MVar) +198047000: cap 0: running thread 5 +198048000: cap 0: waking up thread 1 on cap 0 +198050000: cap 0: stopping thread 5 (thread finished) +198053000: cap 0: running thread 1 +198088000: cap 0: stopping thread 1 (making a foreign call) +198091000: cap 0: running thread 1 +198105000: cap 0: stopping thread 1 (thread finished) +198108000: killing process 1 +198115000: cap 0: creating thread 7 +198117000: creating process 3 +198118000: cap 0: assigning thread 7 to process 3 +198122000: cap 0: running thread 7 +198139000: cap 0: stopping thread 7 (thread finished) +198141000: killing process 3 +198143000: cap 0: starting GC +198152000: cap 0: GC working +198413000: cap 0: GC idle +198414000: cap 0: GC done +198418000: cap 0: GC idle +198419000: cap 0: GC done +198421000: cap 0: GC idle +198423000: cap 0: GC done +198424000: cap 0: GC idle +198426000: cap 0: GC done +198435000: cap 0: finished GC +198437000: removed cap 0 from capset 0 +198438000: removed cap 0 from capset 1 +198440000: deleted capset 0 +198442000: deleted capset 1 +198487000: killing machine 1 + + diff --git a/test/queens-ghc-6.12.1.eventlog b/test/queens-ghc-6.12.1.eventlog new file mode 100644 Binary files /dev/null and b/test/queens-ghc-6.12.1.eventlog differ diff --git a/test/queens-ghc-6.12.1.eventlog.reference b/test/queens-ghc-6.12.1.eventlog.reference new file mode 100644 --- /dev/null +++ b/test/queens-ghc-6.12.1.eventlog.reference @@ -0,0 +1,510 @@ +Event Types: + 0: Create thread (size 8) + 1: Run thread (size 8) + 2: Stop thread (size 10) + 3: Thread runnable (size 8) + 4: Migrate thread (size 10) + 5: Run spark (size 8) + 6: Steal spark (size 10) + 7: Shutdown (size 0) + 8: Wakeup thread (size 10) + 9: Starting GC (size 0) + 10: Finished GC (size 0) + 11: Request sequential GC (size 0) + 12: Request parallel GC (size 0) + 15: Create spark thread (size 8) + 16: Log message (size variable) + 17: Startup (size 0) + 18: Block marker (size 14) + 19: User message (size variable) + +Events: + 106000: startup: 4 capabilities + 431000: cap 3: creating thread 1 + 431000: cap 3: thread 1 is runnable + 432000: cap 3: running thread 1 + 471000: cap 3: creating thread 2 + 471000: cap 3: thread 2 is runnable + 471000: cap 3: stopping thread 1 (thread finished) + 478000: cap 3: creating thread 3 + 479000: cap 3: thread 3 is runnable + 517000: cap 3: running thread 2 + 580000: cap 3: stopping thread 2 (making a foreign call) + 585000: cap 3: running thread 2 + 606000: cap 3: stopping thread 2 (making a foreign call) + 612000: cap 3: running thread 3 + 667000: cap 3: stopping thread 3 (thread yielding) + 668000: cap 3: thread 3 is runnable + 668000: cap 3: running thread 3 + 834000: cap 3: stopping thread 3 (stack overflow) + 839000: cap 3: running thread 3 + 1459000: cap 3: stopping thread 3 (heap overflow) + 1460000: cap 3: requesting parallel GC + 1470000: cap 0: starting GC + 1473000: cap 1: starting GC + 1473000: cap 2: starting GC + 1474000: cap 3: starting GC + 1631000: cap 3: finished GC + 1632000: cap 0: finished GC + 1632000: cap 1: finished GC + 1632000: cap 2: finished GC + 1633000: cap 3: running thread 3 + 1637000: cap 2: creating thread 4 + 1637000: cap 2: creating spark thread 4 + 1637000: cap 2: thread 4 is runnable + 1637000: cap 2: running thread 4 + 1638000: cap 0: creating thread 5 + 1638000: cap 0: creating spark thread 5 + 1638000: cap 3: stopping thread 3 (thread yielding) + 1638000: cap 3: thread 3 is runnable + 1639000: cap 0: thread 5 is runnable + 1639000: cap 0: running thread 5 + 1639000: cap 1: creating thread 6 + 1639000: cap 1: creating spark thread 6 + 1639000: cap 1: thread 6 is runnable + 1639000: cap 3: running thread 3 + 1640000: cap 1: running thread 6 + 1642000: cap 2: stealing a spark from cap 3 + 1647000: cap 0: stealing a spark from cap 3 + 1647000: cap 1: stealing a spark from cap 3 + 1652000: cap 2: stopping thread 4 (thread yielding) + 1653000: cap 2: thread 4 is runnable + 1653000: cap 2: running thread 4 + 1663000: cap 0: stopping thread 5 (thread yielding) + 1663000: cap 1: stopping thread 6 (thread yielding) + 1664000: cap 0: thread 5 is runnable + 1664000: cap 0: running thread 5 + 1664000: cap 1: thread 6 is runnable + 1664000: cap 1: running thread 6 + 1672000: cap 2: stopping thread 4 (stack overflow) + 1676000: cap 2: running thread 4 + 1684000: cap 0: stopping thread 5 (stack overflow) + 1687000: cap 1: stopping thread 6 (stack overflow) + 1688000: cap 0: running thread 5 + 1691000: cap 1: running thread 6 + 1974000: cap 3: stopping thread 3 (heap overflow) + 1974000: cap 3: requesting parallel GC + 1975000: cap 1: stopping thread 6 (thread yielding) + 1975000: cap 1: thread 6 is runnable + 1975000: cap 2: stopping thread 4 (thread yielding) + 1976000: cap 1: starting GC + 1976000: cap 2: thread 4 is runnable + 1976000: cap 2: starting GC + 1977000: cap 0: stopping thread 5 (thread yielding) + 1977000: cap 0: thread 5 is runnable + 1977000: cap 0: starting GC + 1978000: cap 3: starting GC + 2054000: cap 3: finished GC + 2055000: cap 0: finished GC + 2055000: cap 1: finished GC + 2055000: cap 2: finished GC + 2056000: cap 0: running thread 5 + 2056000: cap 1: running thread 6 + 2056000: cap 2: running thread 4 + 2056000: cap 3: running thread 3 + 2066000: cap 0: stopping thread 5 (thread yielding) + 2066000: cap 0: thread 5 is runnable + 2066000: cap 1: stopping thread 6 (thread yielding) + 2066000: cap 2: stopping thread 4 (thread yielding) + 2066000: cap 2: thread 4 is runnable + 2066000: cap 3: stopping thread 3 (thread yielding) + 2066000: cap 3: thread 3 is runnable + 2067000: cap 0: running thread 5 + 2067000: cap 1: thread 6 is runnable + 2067000: cap 1: running thread 6 + 2067000: cap 2: running thread 4 + 2067000: cap 3: running thread 3 + 2413000: cap 3: stopping thread 3 (heap overflow) + 2414000: cap 3: requesting parallel GC + 2417000: cap 0: stopping thread 5 (thread yielding) + 2417000: cap 0: thread 5 is runnable + 2417000: cap 0: starting GC + 2417000: cap 1: stopping thread 6 (thread yielding) + 2417000: cap 1: thread 6 is runnable + 2417000: cap 1: starting GC + 2417000: cap 2: stopping thread 4 (thread yielding) + 2418000: cap 2: thread 4 is runnable + 2418000: cap 2: starting GC + 2419000: cap 3: starting GC + 2457000: cap 3: finished GC + 2458000: cap 0: finished GC + 2458000: cap 0: running thread 5 + 2458000: cap 1: finished GC + 2458000: cap 2: finished GC + 2458000: cap 3: running thread 3 + 2459000: cap 1: running thread 6 + 2459000: cap 2: running thread 4 + 2462000: cap 0: stopping thread 5 (thread yielding) + 2462000: cap 0: thread 5 is runnable + 2462000: cap 2: stopping thread 4 (thread yielding) + 2463000: cap 0: running thread 5 + 2463000: cap 1: stopping thread 6 (thread yielding) + 2463000: cap 2: thread 4 is runnable + 2463000: cap 2: running thread 4 + 2463000: cap 3: stopping thread 3 (thread yielding) + 2463000: cap 3: thread 3 is runnable + 2463000: cap 3: running thread 3 + 2464000: cap 1: thread 6 is runnable + 2464000: cap 1: running thread 6 + 2573000: cap 3: stopping thread 3 (thread blocked) + 2612000: cap 3: creating thread 7 + 2612000: cap 3: creating spark thread 7 + 2612000: cap 3: thread 7 is runnable + 2613000: cap 3: running thread 7 + 2616000: cap 3: running a local spark + 2629000: cap 3: stopping thread 7 (stack overflow) + 2630000: cap 3: running thread 7 + 2845000: cap 3: stopping thread 7 (heap overflow) + 2846000: cap 3: requesting parallel GC + 2848000: cap 1: stopping thread 6 (thread yielding) + 2848000: cap 1: thread 6 is runnable + 2848000: cap 2: stopping thread 4 (thread yielding) + 2848000: cap 2: thread 4 is runnable + 2849000: cap 0: stopping thread 5 (thread yielding) + 2849000: cap 1: starting GC + 2849000: cap 2: starting GC + 2850000: cap 0: thread 5 is runnable + 2850000: cap 0: starting GC + 2851000: cap 3: starting GC + 2890000: cap 0: finished GC + 2890000: cap 1: finished GC + 2890000: cap 3: finished GC + 2891000: cap 0: running thread 5 + 2891000: cap 1: running thread 6 + 2891000: cap 2: finished GC + 2891000: cap 2: running thread 4 + 2891000: cap 3: running thread 7 + 2894000: cap 3: stopping thread 7 (thread yielding) + 2895000: cap 0: stopping thread 5 (thread yielding) + 2895000: cap 1: stopping thread 6 (thread yielding) + 2895000: cap 2: stopping thread 4 (thread yielding) + 2895000: cap 3: thread 7 is runnable + 2895000: cap 3: running thread 7 + 2896000: cap 0: thread 5 is runnable + 2896000: cap 0: running thread 5 + 2896000: cap 1: thread 6 is runnable + 2896000: cap 1: running thread 6 + 2896000: cap 2: thread 4 is runnable + 2896000: cap 2: running thread 4 + 3231000: cap 3: stopping thread 7 (heap overflow) + 3231000: cap 3: requesting parallel GC + 3232000: cap 2: stopping thread 4 (thread yielding) + 3232000: cap 2: thread 4 is runnable + 3232000: cap 2: starting GC + 3233000: cap 0: stopping thread 5 (thread yielding) + 3233000: cap 0: thread 5 is runnable + 3233000: cap 0: starting GC + 3233000: cap 1: stopping thread 6 (thread yielding) + 3233000: cap 1: thread 6 is runnable + 3233000: cap 1: starting GC + 3234000: cap 3: starting GC + 3268000: cap 3: finished GC + 3269000: cap 0: finished GC + 3269000: cap 0: running thread 5 + 3269000: cap 1: finished GC + 3269000: cap 1: running thread 6 + 3269000: cap 2: finished GC + 3269000: cap 3: running thread 7 + 3270000: cap 2: running thread 4 + 3273000: cap 0: stopping thread 5 (thread yielding) + 3274000: cap 0: thread 5 is runnable + 3274000: cap 0: running thread 5 + 3274000: cap 2: stopping thread 4 (thread yielding) + 3274000: cap 2: thread 4 is runnable + 3274000: cap 3: stopping thread 7 (thread yielding) + 3274000: cap 3: thread 7 is runnable + 3275000: cap 1: stopping thread 6 (thread yielding) + 3275000: cap 1: thread 6 is runnable + 3275000: cap 1: running thread 6 + 3275000: cap 2: running thread 4 + 3275000: cap 3: running thread 7 + 3507000: cap 2: stealing a spark from cap 3 + 3524000: cap 0: stealing a spark from cap 2 + 3540000: cap 1: stealing a spark from cap 0 + 3607000: cap 3: stopping thread 7 (heap overflow) + 3607000: cap 3: requesting parallel GC + 3609000: cap 0: stopping thread 5 (thread yielding) + 3609000: cap 0: thread 5 is runnable + 3609000: cap 0: starting GC + 3609000: cap 1: stopping thread 6 (thread yielding) + 3609000: cap 1: thread 6 is runnable + 3609000: cap 1: starting GC + 3609000: cap 2: stopping thread 4 (thread yielding) + 3609000: cap 2: thread 4 is runnable + 3610000: cap 2: starting GC + 3610000: cap 3: thread 3 is runnable + 3610000: cap 3: waking up thread 3 on cap 3 + 3611000: cap 3: starting GC + 3642000: cap 3: finished GC + 3643000: cap 0: finished GC + 3643000: cap 0: running thread 5 + 3643000: cap 1: finished GC + 3643000: cap 2: finished GC + 3643000: cap 2: running thread 4 + 3644000: cap 1: running thread 6 + 3644000: cap 3: running thread 7 + 3647000: cap 0: stopping thread 5 (thread yielding) + 3647000: cap 2: stopping thread 4 (thread yielding) + 3647000: cap 2: thread 4 is runnable + 3648000: cap 0: thread 5 is runnable + 3648000: cap 0: running thread 5 + 3648000: cap 1: stopping thread 6 (thread yielding) + 3648000: cap 1: thread 6 is runnable + 3648000: cap 1: running thread 6 + 3648000: cap 2: running thread 4 + 3648000: cap 3: stopping thread 7 (thread yielding) + 3648000: cap 3: thread 7 is runnable + 3662000: cap 3: running thread 3 + 3666000: cap 3: stopping thread 3 (thread blocked) + 3668000: cap 3: running thread 7 + 3684000: cap 1: stealing a spark from cap 2 + 3692000: cap 0: stealing a spark from cap 1 + 3729000: cap 2: stopping thread 4 (thread blocked) + 3730000: cap 2: creating thread 8 + 3730000: cap 2: creating spark thread 8 + 3731000: cap 2: thread 8 is runnable + 3731000: cap 2: running thread 8 + 3731000: cap 2: running a local spark + 3770000: cap 0: stealing a spark from cap 1 + 3810000: cap 1: stopping thread 6 (thread blocked) + 3812000: cap 1: creating thread 9 + 3813000: cap 1: creating spark thread 9 + 3813000: cap 1: thread 9 is runnable + 3813000: cap 1: running thread 9 + 3814000: cap 1: stealing a spark from cap 2 + 3865000: cap 0: stealing a spark from cap 1 + 3883000: cap 1: stopping thread 9 (thread blocked) + 3884000: cap 1: thread 6 is runnable + 3884000: cap 1: waking up thread 6 on cap 1 + 3884000: cap 1: running thread 6 + 3885000: cap 1: stopping thread 6 (thread yielding) + 3885000: cap 1: thread 6 is runnable + 3885000: cap 1: running thread 6 + 3886000: cap 1: running a local spark + 3955000: cap 0: stealing a spark from cap 1 + 3985000: cap 2: stopping thread 8 (heap overflow) + 3986000: cap 2: requesting parallel GC + 3987000: cap 0: stopping thread 5 (heap overflow) + 3987000: cap 0: thread 5 is runnable + 3987000: cap 0: starting GC + 3987000: cap 1: stealing a spark from cap 3 + 3988000: cap 1: stopping thread 6 (thread yielding) + 3988000: cap 1: thread 6 is runnable + 3988000: cap 1: starting GC + 3988000: cap 3: stopping thread 7 (thread yielding) + 3988000: cap 3: thread 7 is runnable + 3988000: cap 3: starting GC + 3989000: cap 2: waking up thread 9 on cap 1 + 3990000: cap 2: thread 4 is runnable + 3990000: cap 2: waking up thread 4 on cap 2 + 3990000: cap 2: starting GC + 4032000: cap 0: finished GC + 4032000: cap 2: finished GC + 4033000: cap 0: running thread 5 + 4033000: cap 1: finished GC + 4033000: cap 1: running thread 6 + 4033000: cap 2: running thread 8 + 4033000: cap 3: finished GC + 4033000: cap 3: running thread 7 + 4037000: cap 0: stopping thread 5 (thread yielding) + 4037000: cap 0: thread 5 is runnable + 4037000: cap 0: running thread 5 + 4037000: cap 3: stopping thread 7 (thread yielding) + 4037000: cap 3: thread 7 is runnable + 4037000: cap 3: running thread 7 + 4038000: cap 1: stopping thread 6 (thread yielding) + 4038000: cap 1: thread 6 is runnable + 4038000: cap 1: running thread 6 + 4038000: cap 2: stopping thread 8 (thread yielding) + 4038000: cap 2: thread 8 is runnable + 4038000: cap 2: running thread 4 + 4041000: cap 2: stopping thread 4 (thread blocked) + 4041000: cap 2: running thread 8 + 4053000: cap 2: stealing a spark from cap 1 + 4064000: cap 0: stealing a spark from cap 1 + 4102000: cap 3: running a local spark + 4296000: cap 0: stealing a spark from cap 1 + 4308000: cap 2: stealing a spark from cap 0 + 4312000: cap 1: stopping thread 6 (thread blocked) + 4313000: cap 1: running thread 9 + 4314000: cap 1: running a local spark + 4375000: cap 2: stopping thread 8 (heap overflow) + 4375000: cap 2: requesting parallel GC + 4376000: cap 0: stopping thread 5 (heap overflow) + 4376000: cap 0: thread 5 is runnable + 4376000: cap 0: starting GC + 4376000: cap 3: stopping thread 7 (thread yielding) + 4377000: cap 3: thread 7 is runnable + 4377000: cap 3: starting GC + 4378000: cap 1: stopping thread 9 (thread yielding) + 4379000: cap 1: thread 9 is runnable + 4379000: cap 1: starting GC + 4380000: cap 2: thread 4 is runnable + 4380000: cap 2: waking up thread 4 on cap 2 + 4380000: cap 2: waking up thread 3 on cap 3 + 4380000: cap 2: starting GC + 4419000: cap 2: finished GC + 4420000: cap 0: finished GC + 4420000: cap 1: finished GC + 4420000: cap 3: finished GC + 4421000: cap 0: running thread 5 + 4421000: cap 1: running thread 9 + 4421000: cap 2: running thread 8 + 4421000: cap 3: running thread 7 + 4424000: cap 0: stopping thread 5 (thread yielding) + 4424000: cap 0: thread 5 is runnable + 4424000: cap 3: stopping thread 7 (thread yielding) + 4424000: cap 3: thread 7 is runnable + 4425000: cap 0: running thread 5 + 4425000: cap 2: stopping thread 8 (thread yielding) + 4425000: cap 2: thread 8 is runnable + 4425000: cap 2: running thread 4 + 4425000: cap 3: running thread 7 + 4426000: cap 1: stopping thread 9 (thread yielding) + 4426000: cap 1: thread 9 is runnable + 4426000: cap 1: running thread 9 + 4428000: cap 2: stopping thread 4 (thread finished) + 4428000: cap 2: running thread 8 + 4440000: cap 2: stealing a spark from cap 0 + 4466000: cap 0: stopping thread 5 (thread blocked) + 4467000: cap 0: creating thread 10 + 4468000: cap 0: creating spark thread 10 + 4468000: cap 0: thread 10 is runnable + 4468000: cap 0: running thread 10 + 4468000: cap 0: running a local spark + 4497000: cap 2: stealing a spark from cap 1 + 4512000: cap 0: stealing a spark from cap 3 + 4515000: cap 3: stopping thread 7 (thread blocked) + 4527000: cap 3: running thread 3 + 4529000: cap 3: stopping thread 3 (thread blocked) + 4532000: cap 3: waking up thread 5 on cap 0 + 4532000: cap 3: creating thread 11 + 4532000: cap 3: creating spark thread 11 + 4533000: cap 3: thread 11 is runnable + 4533000: cap 3: running thread 11 + 4534000: cap 0: stopping thread 10 (thread yielding) + 4534000: cap 0: thread 10 is runnable + 4534000: cap 3: running a local spark + 4535000: cap 0: running thread 10 + 4547000: cap 1: stopping thread 9 (thread blocked) + 4549000: cap 1: creating thread 12 + 4549000: cap 1: creating spark thread 12 + 4549000: cap 1: thread 12 is runnable + 4549000: cap 1: running thread 12 + 4550000: cap 1: stealing a spark from cap 0 + 4562000: cap 2: stealing a spark from cap 0 + 4595000: cap 2: stealing a spark from cap 3 + 4600000: cap 0: stopping thread 10 (thread blocked) + 4600000: cap 0: running thread 5 + 4601000: cap 0: stealing a spark from cap 2 + 4608000: cap 1: stealing a spark from cap 2 + 4625000: cap 2: stopping thread 8 (thread blocked) + 4626000: cap 2: waking up thread 10 on cap 0 + 4627000: cap 2: waking up thread 9 on cap 1 + 4627000: cap 2: waking up thread 6 on cap 1 + 4628000: cap 0: stopping thread 5 (thread yielding) + 4628000: cap 0: thread 5 is runnable + 4628000: cap 2: creating thread 13 + 4628000: cap 2: creating spark thread 13 + 4628000: cap 2: thread 13 is runnable + 4629000: cap 0: running thread 5 + 4629000: cap 1: stopping thread 12 (thread yielding) + 4629000: cap 1: thread 12 is runnable + 4629000: cap 1: running thread 12 + 4629000: cap 2: running thread 13 + 4629000: cap 2: running a local spark + 4665000: cap 1: stopping thread 12 (thread finished) + 4665000: cap 1: running thread 9 + 4666000: cap 1: stopping thread 9 (thread finished) + 4666000: cap 1: running thread 6 + 4668000: cap 1: stealing a spark from cap 3 + 4669000: cap 0: stopping thread 5 (thread finished) + 4669000: cap 0: running thread 10 + 4670000: cap 0: stopping thread 10 (thread finished) + 4671000: cap 0: waking up thread 8 on cap 2 + 4672000: cap 0: waking up thread 3 on cap 3 + 4672000: cap 0: waking up thread 7 on cap 3 + 4672000: cap 0: creating thread 14 + 4673000: cap 0: creating spark thread 14 + 4673000: cap 0: thread 14 is runnable + 4673000: cap 0: running thread 14 + 4673000: cap 0: stealing a spark from cap 1 + 4673000: cap 3: stopping thread 11 (thread yielding) + 4673000: cap 3: thread 11 is runnable + 4674000: cap 2: stopping thread 13 (thread yielding) + 4674000: cap 2: thread 13 is runnable + 4674000: cap 3: running thread 11 + 4675000: cap 1: stopping thread 6 (thread blocked) + 4675000: cap 1: creating thread 15 + 4675000: cap 2: running thread 13 + 4676000: cap 1: creating spark thread 15 + 4676000: cap 1: thread 15 is runnable + 4676000: cap 1: running thread 15 + 4676000: cap 1: running a local spark + 4685000: cap 2: stopping thread 13 (thread finished) + 4686000: cap 2: running thread 8 + 4687000: cap 2: stealing a spark from cap 1 + 4707000: cap 1: running a local spark + 4711000: cap 3: stopping thread 11 (thread finished) + 4719000: cap 0: stopping thread 14 (thread finished) + 4719000: cap 0: waking up thread 6 on cap 1 + 4721000: cap 1: stopping thread 15 (thread yielding) + 4721000: cap 1: thread 15 is runnable + 4721000: cap 3: running thread 3 + 4722000: cap 0: thread 6 is runnable + 4722000: cap 1: migrating thread 6 to cap 0 + 4724000: cap 3: stopping thread 3 (thread blocked) + 4725000: cap 1: running thread 15 + 4726000: cap 3: running thread 7 + 4728000: cap 0: running thread 6 + 4728000: cap 2: stopping thread 8 (thread finished) + 4732000: cap 3: stopping thread 7 (thread blocked) + 4734000: cap 0: stopping thread 6 (thread blocked) + 4778000: cap 1: stopping thread 15 (heap overflow) + 4779000: cap 1: requesting parallel GC + 4784000: cap 0: starting GC + 4790000: cap 2: starting GC + 4793000: cap 3: starting GC + 4794000: cap 1: starting GC + 4833000: cap 1: finished GC + 4834000: cap 0: finished GC + 4834000: cap 1: running thread 15 + 4834000: cap 2: finished GC + 4834000: cap 3: finished GC + 4838000: cap 1: stopping thread 15 (thread yielding) + 4838000: cap 1: thread 15 is runnable + 4839000: cap 1: running thread 15 + 4846000: cap 0: thread 6 is runnable + 4846000: cap 1: stopping thread 15 (thread finished) + 4849000: cap 1: waking up thread 6 on cap 0 + 4851000: cap 0: running thread 6 + 4852000: cap 0: stopping thread 6 (thread finished) + 4853000: cap 3: thread 7 is runnable + 4857000: cap 0: waking up thread 7 on cap 3 + 4859000: cap 3: running thread 7 + 4861000: cap 3: stopping thread 7 (thread finished) + 4861000: cap 3: thread 3 is runnable + 4861000: cap 3: waking up thread 3 on cap 3 + 4866000: cap 3: running thread 3 + 4903000: cap 3: stopping thread 3 (making a foreign call) + 4904000: cap 3: running thread 3 + 4905000: cap 3: stopping thread 3 (making a foreign call) + 4914000: cap 3: running thread 3 + 4918000: cap 3: stopping thread 3 (thread yielding) + 4918000: cap 3: thread 3 is runnable + 4919000: cap 3: running thread 3 + 4946000: cap 3: stopping thread 3 (thread finished) + 4962000: cap 3: running thread 2 + 4964000: cap 0: requesting sequential GC + 4965000: cap 3: stopping thread 2 (thread yielding) + 4966000: cap 3: thread 2 is runnable + 4972000: cap 0: starting GC + 5026000: cap 0: finished GC + 5037000: cap 3: running thread 2 + 5037000: cap 3: stopping thread 2 (thread finished) + 5053000: cap 0: shutting down + 5054000: cap 1: shutting down + 5104000: cap 2: shutting down + 5105000: cap 3: shutting down + + diff --git a/test/queens-ghc-7.0.2.eventlog b/test/queens-ghc-7.0.2.eventlog new file mode 100644 Binary files /dev/null and b/test/queens-ghc-7.0.2.eventlog differ diff --git a/test/queens-ghc-7.0.2.eventlog.reference b/test/queens-ghc-7.0.2.eventlog.reference new file mode 100644 --- /dev/null +++ b/test/queens-ghc-7.0.2.eventlog.reference @@ -0,0 +1,944 @@ +Event Types: + 0: Create thread (size 4) + 1: Run thread (size 4) + 2: Stop thread (size 6) + 3: Thread runnable (size 4) + 4: Migrate thread (size 6) + 5: Run spark (size 4) + 6: Steal spark (size 6) + 7: Shutdown (size 0) + 8: Wakeup thread (size 6) + 9: Starting GC (size 0) + 10: Finished GC (size 0) + 11: Request sequential GC (size 0) + 12: Request parallel GC (size 0) + 15: Create spark thread (size 4) + 16: Log message (size variable) + 17: Startup (size 2) + 18: Block marker (size 14) + 19: User message (size variable) + 20: GC idle (size 0) + 21: GC working (size 0) + 22: GC done (size 0) + +Events: + 115000: startup: 4 capabilities + 430000: cap 3: creating thread 1 + 430000: cap 3: thread 1 is runnable + 433000: cap 3: running thread 1 + 512000: cap 3: stopping thread 1 (making a foreign call) + 513000: cap 3: running thread 1 + 516000: cap 3: stopping thread 1 (making a foreign call) + 517000: cap 3: running thread 1 + 554000: cap 3: creating thread 2 + 554000: cap 3: thread 2 is runnable + 572000: cap 3: stopping thread 1 (thread finished) + 580000: cap 3: creating thread 3 + 580000: cap 3: thread 3 is runnable + 619000: cap 3: running thread 2 + 635000: cap 3: stopping thread 2 (thread yielding) + 635000: cap 3: thread 2 is runnable + 637000: cap 0: thread 2 is runnable + 637000: cap 3: migrating thread 2 to cap 0 + 648000: cap 0: running thread 2 + 655000: cap 3: running thread 3 + 672000: cap 0: stopping thread 2 (making a foreign call) + 893000: cap 3: stopping thread 3 (stack overflow) + 897000: cap 3: running thread 3 + 1466000: cap 3: stopping thread 3 (heap overflow) + 1467000: cap 3: requesting parallel GC + 1476000: cap 0: starting GC + 1480000: cap 1: starting GC + 1481000: cap 2: starting GC + 1483000: cap 3: starting GC + 1503000: cap 1: GC working + 1503000: cap 2: GC working + 1506000: cap 2: GC idle + 1507000: cap 1: GC idle + 1509000: cap 0: GC working + 1514000: cap 3: GC working + 1566000: cap 0: GC idle + 1628000: cap 0: GC done + 1628000: cap 1: GC done + 1628000: cap 3: GC idle + 1628000: cap 3: GC done + 1629000: cap 2: GC done + 1629000: cap 3: GC working + 1630000: cap 3: GC idle + 1630000: cap 3: GC done + 1630000: cap 3: GC working + 1631000: cap 3: GC idle + 1631000: cap 3: GC done + 1631000: cap 3: GC working + 1631000: cap 3: GC idle + 1632000: cap 3: GC done + 1653000: cap 0: finished GC + 1653000: cap 3: finished GC + 1654000: cap 1: finished GC + 1654000: cap 2: finished GC + 1654000: cap 3: running thread 3 + 1658000: cap 3: stopping thread 3 (thread yielding) + 1659000: cap 2: creating thread 4 + 1659000: cap 2: creating spark thread 4 + 1659000: cap 3: thread 3 is runnable + 1659000: cap 3: running thread 3 + 1660000: cap 0: creating thread 5 + 1660000: cap 0: creating spark thread 5 + 1660000: cap 0: thread 5 is runnable + 1660000: cap 2: thread 4 is runnable + 1660000: cap 2: running thread 4 + 1661000: cap 0: running thread 5 + 1663000: cap 1: creating thread 6 + 1663000: cap 1: creating spark thread 6 + 1663000: cap 1: thread 6 is runnable + 1664000: cap 1: running thread 6 + 1665000: cap 2: stealing a spark from cap 3 + 1667000: cap 0: stealing a spark from cap 3 + 1669000: cap 1: stealing a spark from cap 3 + 1675000: cap 2: stopping thread 4 (thread yielding) + 1675000: cap 2: thread 4 is runnable + 1676000: cap 2: running thread 4 + 1681000: cap 0: stopping thread 5 (thread yielding) + 1681000: cap 0: thread 5 is runnable + 1681000: cap 0: running thread 5 + 1681000: cap 1: stopping thread 6 (thread yielding) + 1681000: cap 1: thread 6 is runnable + 1681000: cap 1: running thread 6 + 1692000: cap 2: stopping thread 4 (stack overflow) + 1694000: cap 2: running thread 4 + 1699000: cap 0: stopping thread 5 (stack overflow) + 1700000: cap 1: stopping thread 6 (stack overflow) + 1705000: cap 0: running thread 5 + 1705000: cap 1: running thread 6 + 1949000: cap 3: stopping thread 3 (heap overflow) + 1950000: cap 3: requesting parallel GC + 1951000: cap 0: stopping thread 5 (thread yielding) + 1951000: cap 0: thread 5 is runnable + 1951000: cap 0: starting GC + 1951000: cap 1: stopping thread 6 (thread yielding) + 1951000: cap 1: thread 6 is runnable + 1951000: cap 1: starting GC + 1951000: cap 2: stopping thread 4 (thread yielding) + 1951000: cap 2: thread 4 is runnable + 1952000: cap 2: starting GC + 1953000: cap 3: starting GC + 1962000: cap 1: GC working + 1963000: cap 2: GC working + 1964000: cap 0: GC working + 1969000: cap 3: GC working + 1990000: cap 2: GC idle + 1991000: cap 0: GC idle + 1992000: cap 1: GC idle + 1999000: cap 0: GC done + 1999000: cap 1: GC done + 1999000: cap 2: GC done + 1999000: cap 3: GC idle + 1999000: cap 3: GC done + 2000000: cap 3: GC working + 2000000: cap 3: GC idle + 2000000: cap 3: GC done + 2000000: cap 3: GC working + 2001000: cap 3: GC idle + 2001000: cap 3: GC done + 2002000: cap 3: GC working + 2002000: cap 3: GC idle + 2002000: cap 3: GC done + 2013000: cap 3: finished GC + 2014000: cap 0: finished GC + 2014000: cap 0: running thread 5 + 2014000: cap 1: finished GC + 2014000: cap 2: finished GC + 2014000: cap 3: running thread 3 + 2015000: cap 1: running thread 6 + 2015000: cap 2: running thread 4 + 2017000: cap 0: stopping thread 5 (thread yielding) + 2018000: cap 0: thread 5 is runnable + 2018000: cap 0: running thread 5 + 2018000: cap 2: stopping thread 4 (thread yielding) + 2018000: cap 2: thread 4 is runnable + 2019000: cap 1: stopping thread 6 (thread yielding) + 2019000: cap 1: thread 6 is runnable + 2019000: cap 2: running thread 4 + 2019000: cap 3: stopping thread 3 (thread yielding) + 2019000: cap 3: thread 3 is runnable + 2019000: cap 3: running thread 3 + 2020000: cap 1: running thread 6 + 2307000: cap 3: stopping thread 3 (heap overflow) + 2307000: cap 3: requesting parallel GC + 2308000: cap 1: stopping thread 6 (thread yielding) + 2309000: cap 1: thread 6 is runnable + 2309000: cap 1: starting GC + 2310000: cap 0: stopping thread 5 (thread yielding) + 2310000: cap 2: stopping thread 4 (thread yielding) + 2310000: cap 2: thread 4 is runnable + 2310000: cap 2: starting GC + 2311000: cap 0: thread 5 is runnable + 2311000: cap 0: starting GC + 2311000: cap 3: starting GC + 2319000: cap 1: GC working + 2320000: cap 2: GC working + 2323000: cap 0: GC working + 2327000: cap 3: GC working + 2333000: cap 2: GC idle + 2334000: cap 0: GC idle + 2335000: cap 3: GC idle + 2336000: cap 0: GC done + 2336000: cap 1: GC idle + 2336000: cap 1: GC done + 2336000: cap 2: GC done + 2336000: cap 3: GC done + 2337000: cap 3: GC working + 2337000: cap 3: GC idle + 2337000: cap 3: GC done + 2337000: cap 3: GC working + 2337000: cap 3: GC idle + 2337000: cap 3: GC done + 2338000: cap 3: GC working + 2338000: cap 3: GC idle + 2338000: cap 3: GC done + 2351000: cap 3: finished GC + 2352000: cap 0: finished GC + 2352000: cap 0: running thread 5 + 2352000: cap 1: finished GC + 2352000: cap 2: finished GC + 2353000: cap 1: running thread 6 + 2353000: cap 2: running thread 4 + 2353000: cap 3: running thread 3 + 2356000: cap 0: stopping thread 5 (thread yielding) + 2356000: cap 0: thread 5 is runnable + 2356000: cap 1: stopping thread 6 (thread yielding) + 2356000: cap 1: thread 6 is runnable + 2356000: cap 2: stopping thread 4 (thread yielding) + 2356000: cap 2: thread 4 is runnable + 2357000: cap 0: running thread 5 + 2357000: cap 1: running thread 6 + 2357000: cap 2: running thread 4 + 2357000: cap 3: stopping thread 3 (thread yielding) + 2357000: cap 3: thread 3 is runnable + 2357000: cap 3: running thread 3 + 2451000: cap 2: stopping thread 4 (thread yielding) + 2451000: cap 2: thread 4 is runnable + 2452000: cap 3: stopping thread 3 (thread blocked) + 2452000: cap 3: creating thread 7 + 2453000: cap 2: running thread 4 + 2453000: cap 3: creating spark thread 7 + 2453000: cap 3: thread 7 is runnable + 2463000: cap 3: running thread 7 + 2465000: cap 3: running a local spark + 2480000: cap 3: stopping thread 7 (stack overflow) + 2481000: cap 3: running thread 7 + 2749000: cap 2: stopping thread 4 (heap overflow) + 2750000: cap 2: requesting parallel GC + 2751000: cap 1: stopping thread 6 (thread yielding) + 2751000: cap 3: stopping thread 7 (thread yielding) + 2752000: cap 1: thread 6 is runnable + 2752000: cap 1: starting GC + 2752000: cap 3: thread 7 is runnable + 2752000: cap 3: starting GC + 6061000: cap 0: stopping thread 5 (thread yielding) + 6062000: cap 0: thread 5 is runnable + 6062000: cap 0: starting GC + 6063000: cap 2: starting GC + 6074000: cap 1: GC working + 6075000: cap 0: GC working + 6075000: cap 2: GC working + 6076000: cap 3: GC working + 6079000: cap 2: GC idle + 6082000: cap 1: GC idle + 6084000: cap 0: GC idle + 6090000: cap 0: GC done + 6090000: cap 1: GC done + 6090000: cap 2: GC done + 6090000: cap 3: GC idle + 6090000: cap 3: GC done + 6091000: cap 2: GC working + 6091000: cap 2: GC idle + 6091000: cap 2: GC done + 6091000: cap 2: GC working + 6091000: cap 2: GC idle + 6091000: cap 2: GC done + 6092000: cap 2: GC working + 6092000: cap 2: GC idle + 6092000: cap 2: GC done + 6107000: cap 0: finished GC + 6107000: cap 2: finished GC + 6108000: cap 0: running thread 5 + 6108000: cap 1: finished GC + 6108000: cap 1: running thread 6 + 6108000: cap 2: running thread 4 + 6108000: cap 3: finished GC + 6109000: cap 3: running thread 7 + 6113000: cap 1: stopping thread 6 (thread yielding) + 6113000: cap 1: thread 6 is runnable + 6114000: cap 1: running thread 6 + 6114000: cap 2: stopping thread 4 (thread yielding) + 6115000: cap 0: stopping thread 5 (thread yielding) + 6115000: cap 2: thread 4 is runnable + 6115000: cap 2: running thread 4 + 6115000: cap 3: stopping thread 7 (thread yielding) + 6115000: cap 3: thread 7 is runnable + 6116000: cap 0: thread 5 is runnable + 6116000: cap 0: running thread 5 + 6116000: cap 3: running thread 7 + 6403000: cap 2: stopping thread 4 (heap overflow) + 6403000: cap 2: requesting parallel GC + 6404000: cap 0: stopping thread 5 (thread yielding) + 6404000: cap 0: thread 5 is runnable + 6404000: cap 1: stopping thread 6 (heap overflow) + 6404000: cap 1: thread 6 is runnable + 6404000: cap 3: stopping thread 7 (thread yielding) + 6405000: cap 0: starting GC + 6405000: cap 1: starting GC + 6405000: cap 3: thread 7 is runnable + 6405000: cap 3: starting GC + 6406000: cap 2: starting GC + 6414000: cap 3: GC working + 6415000: cap 0: GC working + 6415000: cap 1: GC working + 6417000: cap 2: GC working + 6420000: cap 1: GC idle + 6421000: cap 0: GC idle + 6422000: cap 2: GC idle + 6425000: cap 0: GC done + 6425000: cap 1: GC done + 6425000: cap 2: GC done + 6425000: cap 3: GC idle + 6425000: cap 3: GC done + 6426000: cap 2: GC working + 6426000: cap 2: GC idle + 6426000: cap 2: GC done + 6426000: cap 2: GC working + 6426000: cap 2: GC idle + 6427000: cap 2: GC done + 6427000: cap 2: GC working + 6427000: cap 2: GC idle + 6427000: cap 2: GC done + 6440000: cap 0: finished GC + 6440000: cap 2: finished GC + 6441000: cap 0: running thread 5 + 6441000: cap 1: finished GC + 6441000: cap 1: running thread 6 + 6441000: cap 2: running thread 4 + 6441000: cap 3: finished GC + 6442000: cap 3: running thread 7 + 6445000: cap 0: stopping thread 5 (thread yielding) + 6445000: cap 0: thread 5 is runnable + 6445000: cap 1: stopping thread 6 (thread yielding) + 6445000: cap 3: stopping thread 7 (thread yielding) + 6445000: cap 3: thread 7 is runnable + 6445000: cap 3: running thread 7 + 6446000: cap 0: running thread 5 + 6446000: cap 1: thread 6 is runnable + 6446000: cap 1: running thread 6 + 6446000: cap 2: stopping thread 4 (thread yielding) + 6446000: cap 2: thread 4 is runnable + 6446000: cap 2: running thread 4 + 6648000: cap 1: stealing a spark from cap 0 + 6653000: cap 0: stopping thread 5 (thread blocked) + 6653000: cap 0: creating thread 8 + 6653000: cap 1: stopping thread 6 (thread yielding) + 6653000: cap 1: thread 6 is runnable + 6654000: cap 0: creating spark thread 8 + 6654000: cap 0: thread 8 is runnable + 6654000: cap 0: running thread 8 + 6655000: cap 0: running a local spark + 6655000: cap 1: running thread 6 + 6656000: cap 2: waking up thread 3 on cap 3 + 6658000: cap 2: stealing a spark from cap 1 + 6658000: cap 3: stopping thread 7 (thread yielding) + 6658000: cap 3: thread 7 is runnable + 6659000: cap 3: waking up thread 3 on cap 3 + 6659000: cap 3: thread 3 is runnable + 6660000: cap 3: running thread 7 + 6727000: cap 2: stopping thread 4 (heap overflow) + 6728000: cap 1: stopping thread 6 (thread yielding) + 6728000: cap 2: requesting parallel GC + 6729000: cap 0: stopping thread 8 (thread yielding) + 6729000: cap 0: thread 8 is runnable + 6729000: cap 0: starting GC + 6729000: cap 1: thread 6 is runnable + 6729000: cap 1: starting GC + 6729000: cap 3: stopping thread 7 (thread yielding) + 6729000: cap 3: thread 7 is runnable + 6730000: cap 2: starting GC + 6730000: cap 3: starting GC + 6737000: cap 0: GC working + 6737000: cap 2: GC working + 6738000: cap 1: GC working + 6739000: cap 3: GC working + 6741000: cap 2: GC idle + 6744000: cap 1: GC idle + 6747000: cap 3: GC idle + 6748000: cap 0: GC idle + 6748000: cap 1: GC done + 6748000: cap 2: GC done + 6749000: cap 0: GC done + 6749000: cap 2: GC working + 6749000: cap 2: GC idle + 6749000: cap 2: GC done + 6749000: cap 3: GC done + 6750000: cap 2: GC working + 6750000: cap 2: GC idle + 6750000: cap 2: GC done + 6750000: cap 2: GC working + 6750000: cap 2: GC idle + 6750000: cap 2: GC done + 6764000: cap 0: finished GC + 6764000: cap 0: running thread 8 + 6764000: cap 1: finished GC + 6764000: cap 2: finished GC + 6765000: cap 1: running thread 6 + 6765000: cap 2: running thread 4 + 6765000: cap 3: finished GC + 6768000: cap 1: stopping thread 6 (thread yielding) + 6769000: cap 0: stopping thread 8 (thread yielding) + 6769000: cap 0: thread 8 is runnable + 6769000: cap 1: thread 6 is runnable + 6769000: cap 1: running thread 6 + 6769000: cap 2: stopping thread 4 (thread yielding) + 6769000: cap 2: thread 4 is runnable + 6770000: cap 2: running thread 4 + 6777000: cap 3: running thread 3 + 6780000: cap 3: stopping thread 3 (thread blocked) + 6782000: cap 1: stopping thread 6 (thread blocked) + 6782000: cap 2: stopping thread 4 (thread yielding) + 6782000: cap 2: thread 4 is runnable + 6784000: cap 1: creating thread 9 + 6784000: cap 1: creating spark thread 9 + 6784000: cap 2: running thread 4 + 6785000: cap 1: thread 9 is runnable + 6785000: cap 1: running thread 9 + 6786000: cap 1: stealing a spark from cap 0 + 6790000: cap 3: running thread 7 + 6791000: cap 0: running thread 8 + 6794000: cap 3: stopping thread 7 (thread yielding) + 6794000: cap 3: thread 7 is runnable + 6795000: cap 0: stopping thread 8 (thread yielding) + 6795000: cap 0: thread 8 is runnable + 6795000: cap 3: running thread 7 + 6796000: cap 0: running thread 8 + 6802000: cap 2: waking up thread 6 on cap 1 + 6803000: cap 2: stealing a spark from cap 0 + 6804000: cap 1: stopping thread 9 (thread yielding) + 6804000: cap 1: thread 9 is runnable + 6805000: cap 1: waking up thread 6 on cap 1 + 6805000: cap 1: thread 6 is runnable + 6805000: cap 1: running thread 9 + 6818000: cap 1: stopping thread 9 (thread finished) + 6819000: cap 1: running thread 6 + 6819000: cap 1: waking up thread 5 on cap 0 + 6820000: cap 0: stopping thread 8 (thread yielding) + 6820000: cap 1: stealing a spark from cap 3 + 6821000: cap 0: thread 8 is runnable + 6821000: cap 0: waking up thread 5 on cap 0 + 6821000: cap 0: thread 5 is runnable + 6821000: cap 0: running thread 8 + 6828000: cap 0: stopping thread 8 (thread blocked) + 6828000: cap 0: running thread 5 + 6828000: cap 2: stopping thread 4 (thread yielding) + 6829000: cap 2: thread 4 is runnable + 6829000: cap 2: running thread 4 + 6830000: cap 0: stopping thread 5 (thread blocked) + 6831000: cap 0: creating thread 10 + 6831000: cap 0: creating spark thread 10 + 6831000: cap 0: thread 10 is runnable + 6831000: cap 0: running thread 10 + 6832000: cap 0: stealing a spark from cap 1 + 6857000: cap 2: waking up thread 8 on cap 0 + 6857000: cap 2: stealing a spark from cap 0 + 6858000: cap 0: stopping thread 10 (thread yielding) + 6858000: cap 0: thread 10 is runnable + 6858000: cap 0: waking up thread 8 on cap 0 + 6859000: cap 0: thread 8 is runnable + 6859000: cap 0: running thread 10 + 6940000: cap 0: stopping thread 10 (thread blocked) + 6940000: cap 0: running thread 8 + 6940000: cap 2: stopping thread 4 (thread yielding) + 6941000: cap 0: waking up thread 5 on cap 0 + 6941000: cap 0: thread 5 is runnable + 6941000: cap 0: stopping thread 8 (thread finished) + 6941000: cap 0: running thread 5 + 6941000: cap 2: thread 4 is runnable + 6941000: cap 2: running thread 4 + 6942000: cap 0: waking up thread 3 on cap 3 + 6942000: cap 0: stealing a spark from cap 1 + 6943000: cap 3: stopping thread 7 (thread yielding) + 6943000: cap 3: thread 7 is runnable + 6944000: cap 2: waking up thread 10 on cap 0 + 6944000: cap 3: waking up thread 3 on cap 3 + 6944000: cap 3: thread 3 is runnable + 6944000: cap 3: running thread 7 + 6945000: cap 0: stopping thread 5 (thread yielding) + 6945000: cap 0: thread 5 is runnable + 6945000: cap 2: stealing a spark from cap 0 + 6946000: cap 0: waking up thread 10 on cap 0 + 6946000: cap 0: thread 10 is runnable + 6946000: cap 0: running thread 5 + 6949000: cap 0: stopping thread 5 (thread blocked) + 6949000: cap 0: running thread 10 + 6950000: cap 0: running a local spark + 6950000: cap 2: stopping thread 4 (thread yielding) + 6950000: cap 2: thread 4 is runnable + 6950000: cap 2: running thread 4 + 6974000: cap 0: stopping thread 10 (thread yielding) + 6974000: cap 1: stopping thread 6 (thread blocked) + 6975000: cap 0: thread 10 is runnable + 6975000: cap 0: running thread 10 + 6975000: cap 1: creating thread 11 + 6975000: cap 1: creating spark thread 11 + 6976000: cap 1: thread 11 is runnable + 6976000: cap 1: running thread 11 + 6977000: cap 1: running a local spark + 7019000: cap 0: running a local spark + 7046000: cap 2: waking up thread 5 on cap 0 + 7047000: cap 0: stopping thread 10 (thread yielding) + 7047000: cap 0: thread 10 is runnable + 7047000: cap 0: waking up thread 5 on cap 0 + 7047000: cap 0: thread 5 is runnable + 7047000: cap 2: stealing a spark from cap 1 + 7048000: cap 0: running thread 10 + 7066000: cap 2: stopping thread 4 (heap overflow) + 7066000: cap 2: requesting parallel GC + 7067000: cap 1: stopping thread 11 (thread yielding) + 7068000: cap 1: thread 11 is runnable + 7068000: cap 1: starting GC + 7068000: cap 3: stopping thread 7 (thread yielding) + 7068000: cap 3: thread 7 is runnable + 7068000: cap 3: starting GC + 7069000: cap 0: stopping thread 10 (thread yielding) + 7069000: cap 0: thread 10 is runnable + 7070000: cap 0: starting GC + 7070000: cap 2: starting GC + 7078000: cap 0: GC working + 7078000: cap 2: GC working + 7083000: cap 2: GC idle + 7090000: cap 0: GC idle + 7111000: cap 1: GC working + 7121000: cap 1: GC idle + 7141000: cap 3: GC working + 7150000: cap 0: GC done + 7150000: cap 1: GC done + 7150000: cap 2: GC done + 7150000: cap 3: GC idle + 7150000: cap 3: GC done + 7151000: cap 2: GC working + 7151000: cap 2: GC idle + 7151000: cap 2: GC done + 7151000: cap 2: GC working + 7152000: cap 2: GC idle + 7152000: cap 2: GC done + 7152000: cap 2: GC working + 7152000: cap 2: GC idle + 7152000: cap 2: GC done + 7166000: cap 2: finished GC + 7167000: cap 0: finished GC + 7167000: cap 0: running thread 5 + 7167000: cap 1: finished GC + 7168000: cap 1: running thread 11 + 7168000: cap 2: running thread 4 + 7168000: cap 3: finished GC + 7169000: cap 0: stopping thread 5 (thread blocked) + 7170000: cap 0: running thread 10 + 7172000: cap 1: stopping thread 11 (thread yielding) + 7172000: cap 1: thread 11 is runnable + 7172000: cap 2: stopping thread 4 (thread yielding) + 7172000: cap 2: thread 4 is runnable + 7174000: cap 0: stopping thread 10 (thread yielding) + 7174000: cap 0: thread 10 is runnable + 7174000: cap 0: running thread 10 + 7174000: cap 2: running thread 4 + 7175000: cap 1: running thread 11 + 7228000: cap 0: waking up thread 5 on cap 0 + 7228000: cap 0: thread 5 is runnable + 7228000: cap 0: stopping thread 10 (thread finished) + 7228000: cap 0: running thread 5 + 7229000: cap 0: waking up thread 6 on cap 1 + 7230000: cap 0: stealing a spark from cap 1 + 7231000: cap 1: stopping thread 11 (thread yielding) + 7231000: cap 1: thread 11 is runnable + 7231000: cap 1: waking up thread 6 on cap 1 + 7232000: cap 1: thread 6 is runnable + 7232000: cap 1: running thread 11 + 7249000: cap 1: stopping thread 11 (thread blocked) + 7249000: cap 1: running thread 6 + 7250000: cap 0: stopping thread 5 (thread yielding) + 7250000: cap 0: thread 5 is runnable + 7251000: cap 0: running thread 5 + 7253000: cap 1: stopping thread 6 (thread blocked) + 7254000: cap 1: creating thread 12 + 7254000: cap 1: creating spark thread 12 + 7254000: cap 1: thread 12 is runnable + 7254000: cap 1: running thread 12 + 7255000: cap 1: stealing a spark from cap 2 + 7294000: cap 1: stopping thread 12 (thread yielding) + 7294000: cap 2: stopping thread 4 (thread blocked) + 7295000: cap 1: thread 12 is runnable + 7295000: cap 1: running thread 12 + 7295000: cap 2: creating thread 13 + 7295000: cap 2: creating spark thread 13 + 7295000: cap 2: thread 13 is runnable + 7296000: cap 2: running thread 13 + 7297000: cap 2: running a local spark + 7300000: cap 0: waking up thread 11 on cap 1 + 7301000: cap 0: stealing a spark from cap 3 + 7301000: cap 1: stopping thread 12 (thread yielding) + 7301000: cap 1: thread 12 is runnable + 7302000: cap 1: waking up thread 11 on cap 1 + 7302000: cap 1: thread 11 is runnable + 7303000: cap 1: running thread 12 + 7341000: cap 1: waking up thread 4 on cap 2 + 7342000: cap 1: stopping thread 12 (thread finished) + 7342000: cap 1: running thread 11 + 7342000: cap 2: stopping thread 13 (thread yielding) + 7342000: cap 2: thread 13 is runnable + 7343000: cap 1: waking up thread 6 on cap 1 + 7343000: cap 2: waking up thread 4 on cap 2 + 7343000: cap 2: thread 4 is runnable + 7344000: cap 1: thread 6 is runnable + 7344000: cap 1: stopping thread 11 (thread finished) + 7344000: cap 1: running thread 6 + 7344000: cap 2: running thread 13 + 7346000: cap 1: stopping thread 6 (thread blocked) + 7346000: cap 1: creating thread 14 + 7346000: cap 2: stopping thread 13 (thread yielding) + 7346000: cap 2: thread 13 is runnable + 7347000: cap 1: creating spark thread 14 + 7347000: cap 1: thread 14 is runnable + 7347000: cap 1: running thread 14 + 7347000: cap 2: running thread 4 + 7347000: cap 2: stopping thread 4 (thread blocked) + 7348000: cap 1: stealing a spark from cap 0 + 7348000: cap 2: running thread 13 + 7349000: cap 2: waking up thread 4 on cap 2 + 7349000: cap 2: thread 4 is runnable + 7349000: cap 2: stopping thread 13 (thread finished) + 7350000: cap 2: running thread 4 + 7350000: cap 2: waking up thread 6 on cap 1 + 7350000: cap 2: stealing a spark from cap 0 + 7351000: cap 1: stopping thread 14 (thread yielding) + 7351000: cap 1: thread 14 is runnable + 7351000: cap 1: waking up thread 6 on cap 1 + 7352000: cap 1: thread 6 is runnable + 7353000: cap 1: running thread 14 + 7468000: cap 2: stopping thread 4 (heap overflow) + 7468000: cap 2: requesting parallel GC + 7469000: cap 1: stopping thread 14 (thread yielding) + 7469000: cap 1: thread 14 is runnable + 7471000: cap 1: starting GC + 7472000: cap 0: stopping thread 5 (thread yielding) + 7472000: cap 0: thread 5 is runnable + 7473000: cap 0: starting GC + 7502000: cap 3: starting GC + 7503000: cap 2: starting GC + 7510000: cap 1: GC working + 7514000: cap 2: GC working + 7518000: cap 2: GC idle + 7518000: cap 3: GC working + 7523000: cap 3: GC idle + 7524000: cap 1: GC idle + 8359000: cap 0: GC working + 8368000: cap 0: GC idle + 8368000: cap 0: GC done + 8368000: cap 1: GC done + 8368000: cap 2: GC done + 8368000: cap 3: GC done + 8369000: cap 2: GC working + 8369000: cap 2: GC idle + 8369000: cap 2: GC done + 8369000: cap 2: GC working + 8369000: cap 2: GC idle + 8369000: cap 2: GC done + 8370000: cap 2: GC working + 8370000: cap 2: GC idle + 8370000: cap 2: GC done + 8383000: cap 0: finished GC + 8383000: cap 2: finished GC + 8384000: cap 0: running thread 5 + 8384000: cap 1: finished GC + 8384000: cap 1: running thread 6 + 8384000: cap 2: running thread 4 + 8384000: cap 3: finished GC + 8384000: cap 3: running thread 3 + 8385000: cap 1: stopping thread 6 (thread finished) + 8386000: cap 1: running thread 14 + 8389000: cap 2: stopping thread 4 (thread yielding) + 8389000: cap 2: thread 4 is runnable + 8389000: cap 2: running thread 4 + 8389000: cap 3: stopping thread 3 (thread blocked) + 8390000: cap 1: stopping thread 14 (thread yielding) + 8390000: cap 1: thread 14 is runnable + 8393000: cap 0: stopping thread 5 (thread yielding) + 8393000: cap 0: thread 5 is runnable + 8400000: cap 3: running thread 7 + 8403000: cap 3: stopping thread 7 (thread yielding) + 8403000: cap 3: thread 7 is runnable + 8403000: cap 3: running thread 7 + 8404000: cap 1: running thread 14 + 8465000: cap 2: stealing a spark from cap 0 + 8504000: cap 1: stealing a spark from cap 0 + 8623000: cap 3: waking up thread 3 on cap 3 + 8623000: cap 3: thread 3 is runnable + 8623000: cap 3: stopping thread 7 (thread finished) + 8634000: cap 0: running thread 5 + 8635000: cap 3: running thread 3 + 8640000: cap 0: stopping thread 5 (thread yielding) + 8640000: cap 0: thread 5 is runnable + 8640000: cap 3: stopping thread 3 (thread blocked) + 8641000: cap 3: creating thread 15 + 8641000: cap 3: creating spark thread 15 + 8641000: cap 3: thread 15 is runnable + 8649000: cap 3: running thread 15 + 8650000: cap 3: running a local spark + 8661000: cap 3: stopping thread 15 (stack overflow) + 8663000: cap 3: running thread 15 + 8670000: cap 2: stopping thread 4 (heap overflow) + 8670000: cap 2: requesting parallel GC + 8671000: cap 1: stopping thread 14 (thread yielding) + 8671000: cap 1: thread 14 is runnable + 8671000: cap 3: stopping thread 15 (thread yielding) + 8671000: cap 3: thread 15 is runnable + 8671000: cap 3: starting GC + 8672000: cap 1: starting GC + 13162000: cap 0: starting GC + 13162000: cap 2: starting GC + 13170000: cap 1: GC working + 13171000: cap 0: GC working + 13172000: cap 2: GC working + 13177000: cap 1: GC idle + 13178000: cap 0: GC idle + 13178000: cap 2: GC idle + 13186000: cap 3: GC working + 13204000: cap 1: GC done + 13204000: cap 2: GC done + 13204000: cap 3: GC idle + 13204000: cap 3: GC done + 13205000: cap 2: GC working + 13205000: cap 2: GC idle + 13205000: cap 2: GC done + 13205000: cap 2: GC working + 13205000: cap 2: GC idle + 13205000: cap 2: GC done + 13206000: cap 2: GC working + 13206000: cap 2: GC idle + 13206000: cap 2: GC done + 13229000: cap 0: GC done + 13244000: cap 0: finished GC + 13244000: cap 2: finished GC + 13245000: cap 0: running thread 5 + 13245000: cap 1: finished GC + 13245000: cap 1: running thread 14 + 13245000: cap 2: running thread 4 + 13249000: cap 1: stopping thread 14 (thread yielding) + 13249000: cap 1: thread 14 is runnable + 13249000: cap 2: stopping thread 4 (thread yielding) + 13249000: cap 2: thread 4 is runnable + 13249000: cap 2: running thread 4 + 13250000: cap 0: stopping thread 5 (thread yielding) + 13250000: cap 0: thread 5 is runnable + 13250000: cap 1: running thread 14 + 13251000: cap 0: running thread 5 + 13292000: cap 2: stealing a spark from cap 0 + 13294000: cap 1: stealing a spark from cap 3 + 13312000: cap 0: stopping thread 5 (thread blocked) + 13312000: cap 2: stopping thread 4 (thread yielding) + 13312000: cap 2: thread 4 is runnable + 13313000: cap 0: creating thread 16 + 13313000: cap 0: creating spark thread 16 + 13313000: cap 0: thread 16 is runnable + 13314000: cap 0: running thread 16 + 13314000: cap 0: stealing a spark from cap 1 + 13314000: cap 2: running thread 4 + 13340000: cap 2: waking up thread 5 on cap 0 + 13341000: cap 0: stopping thread 16 (thread yielding) + 13341000: cap 0: thread 16 is runnable + 13341000: cap 2: stealing a spark from cap 1 + 13342000: cap 0: waking up thread 5 on cap 0 + 13342000: cap 0: thread 5 is runnable + 13342000: cap 0: running thread 16 + 13364000: cap 0: stopping thread 16 (thread yielding) + 13364000: cap 0: thread 16 is runnable + 13364000: cap 0: running thread 16 + 13364000: cap 1: stopping thread 14 (thread blocked) + 13365000: cap 1: creating thread 17 + 13365000: cap 1: creating spark thread 17 + 13365000: cap 1: thread 17 is runnable + 13365000: cap 1: running thread 17 + 13365000: cap 1: stealing a spark from cap 3 + 13375000: cap 2: stealing a spark from cap 1 + 13423000: cap 2: stealing a spark from cap 1 + 13428000: cap 0: waking up thread 14 on cap 1 + 13429000: cap 0: stopping thread 16 (thread finished) + 13429000: cap 0: running thread 5 + 13430000: cap 1: stopping thread 17 (thread yielding) + 13430000: cap 1: thread 17 is runnable + 13431000: cap 1: waking up thread 14 on cap 1 + 13431000: cap 1: thread 14 is runnable + 13431000: cap 1: running thread 17 + 13432000: cap 0: waking up thread 3 on cap 3 + 13433000: cap 0: stealing a spark from cap 3 + 13442000: cap 1: stopping thread 17 (thread blocked) + 13442000: cap 1: running thread 14 + 13442000: cap 2: stopping thread 4 (thread yielding) + 13442000: cap 2: thread 4 is runnable + 13443000: cap 1: stealing a spark from cap 0 + 13443000: cap 2: running thread 4 + 13453000: cap 2: waking up thread 17 on cap 1 + 13454000: cap 2: stealing a spark from cap 0 + 13455000: cap 1: stopping thread 14 (thread yielding) + 13455000: cap 1: thread 14 is runnable + 13456000: cap 1: waking up thread 17 on cap 1 + 13456000: cap 1: thread 17 is runnable + 13456000: cap 1: running thread 14 + 13476000: cap 1: stopping thread 14 (thread finished) + 13476000: cap 1: running thread 17 + 13476000: cap 1: stealing a spark from cap 3 + 13505000: cap 2: stealing a spark from cap 1 + 13539000: cap 2: stopping thread 4 (heap overflow) + 13539000: cap 2: requesting parallel GC + 13541000: cap 0: stopping thread 5 (thread yielding) + 13541000: cap 0: thread 5 is runnable + 13541000: cap 0: starting GC + 13541000: cap 1: stopping thread 17 (thread yielding) + 13541000: cap 1: thread 17 is runnable + 13541000: cap 1: starting GC + 13578000: cap 3: finished GC + 13578000: cap 3: starting GC + 13579000: cap 2: starting GC + 13585000: cap 1: GC working + 13591000: cap 2: GC working + 13593000: cap 3: GC working + 13595000: cap 2: GC idle + 13596000: cap 1: GC idle + 13603000: cap 3: GC idle + 13880000: cap 0: GC working + 13885000: cap 0: GC idle + 13885000: cap 0: GC done + 13885000: cap 2: GC done + 13886000: cap 1: GC done + 13886000: cap 2: GC working + 13886000: cap 2: GC idle + 13886000: cap 2: GC done + 13886000: cap 2: GC working + 13886000: cap 2: GC idle + 13886000: cap 2: GC done + 13887000: cap 2: GC working + 13887000: cap 2: GC idle + 13887000: cap 2: GC done + 13911000: cap 3: GC done + 13924000: cap 2: finished GC + 13925000: cap 1: finished GC + 13925000: cap 1: running thread 17 + 13925000: cap 2: running thread 4 + 13925000: cap 3: finished GC + 13926000: cap 3: running thread 15 + 13928000: cap 1: stopping thread 17 (thread yielding) + 13928000: cap 2: stopping thread 4 (thread yielding) + 13929000: cap 1: thread 17 is runnable + 13929000: cap 1: running thread 17 + 13929000: cap 2: thread 4 is runnable + 13929000: cap 2: running thread 4 + 13931000: cap 3: stopping thread 15 (thread yielding) + 13931000: cap 3: thread 15 is runnable + 13931000: cap 3: waking up thread 3 on cap 3 + 13931000: cap 3: thread 3 is runnable + 13932000: cap 3: running thread 15 + 13941000: cap 2: stealing a spark from cap 1 + 13944000: cap 1: stopping thread 17 (thread blocked) + 13944000: cap 2: stopping thread 4 (thread yielding) + 13945000: cap 1: creating thread 18 + 13945000: cap 1: creating spark thread 18 + 13945000: cap 1: thread 18 is runnable + 13945000: cap 1: running thread 18 + 13945000: cap 2: thread 4 is runnable + 13946000: cap 1: stealing a spark from cap 3 + 13946000: cap 2: running thread 4 + 13990000: cap 2: waking up thread 17 on cap 1 + 13991000: cap 2: stealing a spark from cap 1 + 13992000: cap 1: stopping thread 18 (thread yielding) + 13992000: cap 1: thread 18 is runnable + 13992000: cap 1: waking up thread 17 on cap 1 + 13992000: cap 1: thread 17 is runnable + 13993000: cap 1: running thread 18 + 14018000: cap 1: stopping thread 18 (thread blocked) + 14018000: cap 1: running thread 17 + 14018000: cap 1: running a local spark + 14019000: cap 2: stopping thread 4 (thread yielding) + 14019000: cap 2: thread 4 is runnable + 14020000: cap 2: running thread 4 + 14029000: cap 2: waking up thread 18 on cap 1 + 14030000: cap 1: stopping thread 17 (thread yielding) + 14030000: cap 1: thread 17 is runnable + 14030000: cap 1: waking up thread 18 on cap 1 + 14030000: cap 2: stealing a spark from cap 3 + 14031000: cap 1: thread 18 is runnable + 14031000: cap 1: running thread 17 + 14035000: cap 3: stopping thread 15 (thread blocked) + 14036000: cap 2: stopping thread 4 (thread yielding) + 14036000: cap 2: thread 4 is runnable + 14036000: cap 2: running thread 4 + 14042000: cap 0: finished GC + 14042000: cap 0: running thread 5 + 14042000: cap 3: running thread 3 + 14045000: cap 3: stopping thread 3 (thread blocked) + 14047000: cap 0: stopping thread 5 (thread yielding) + 14047000: cap 0: thread 5 is runnable + 14048000: cap 0: running thread 5 + 14052000: cap 0: stopping thread 5 (thread finished) + 14057000: cap 2: waking up thread 15 on cap 3 + 14061000: cap 2: stopping thread 4 (thread finished) + 14064000: cap 3: waking up thread 15 on cap 3 + 14065000: cap 3: thread 15 is runnable + 14065000: cap 3: running thread 15 + 14068000: cap 1: stopping thread 17 (thread yielding) + 14068000: cap 1: thread 17 is runnable + 14068000: cap 3: stopping thread 15 (thread blocked) + 14070000: cap 0: thread 17 is runnable + 14070000: cap 1: migrating thread 17 to cap 0 + 14075000: cap 0: running thread 17 + 14078000: cap 1: running thread 18 + 14079000: cap 1: stopping thread 18 (thread blocked) + 14080000: cap 0: stopping thread 17 (thread yielding) + 14080000: cap 0: thread 17 is runnable + 14081000: cap 0: running thread 17 + 14094000: cap 0: waking up thread 18 on cap 1 + 14096000: cap 0: stopping thread 17 (thread finished) + 14098000: cap 1: waking up thread 18 on cap 1 + 14098000: cap 1: thread 18 is runnable + 14099000: cap 1: running thread 18 + 14099000: cap 1: waking up thread 15 on cap 3 + 14102000: cap 1: stopping thread 18 (thread finished) + 14103000: cap 3: waking up thread 15 on cap 3 + 14103000: cap 3: thread 15 is runnable + 14103000: cap 3: running thread 15 + 14103000: cap 3: waking up thread 3 on cap 3 + 14104000: cap 3: thread 3 is runnable + 14104000: cap 3: stopping thread 15 (thread finished) + 14110000: cap 3: running thread 3 + 14146000: cap 3: stopping thread 3 (making a foreign call) + 14147000: cap 3: running thread 3 + 14147000: cap 3: stopping thread 3 (making a foreign call) + 14157000: cap 3: running thread 3 + 14191000: cap 3: stopping thread 3 (thread finished) + 14204000: cap 3: requesting sequential GC + 14206000: cap 3: starting GC + 14229000: cap 0: GC working + 14242000: cap 0: GC idle + 14242000: cap 0: GC done + 14243000: cap 0: GC working + 14243000: cap 0: GC idle + 14244000: cap 0: GC done + 14244000: cap 0: GC working + 14244000: cap 0: GC idle + 14244000: cap 0: GC done + 14244000: cap 0: GC working + 14244000: cap 0: GC idle + 14245000: cap 0: GC done + 14254000: cap 3: finished GC + 14261000: cap 0: running thread 2 + 14306000: cap 0: stopping thread 2 (thread finished) + 14344000: cap 0: shutting down + 14345000: cap 1: shutting down + 14346000: cap 2: shutting down + 14346000: cap 3: shutting down + +