Running... [                                        ] 0% | ETA: 0s | 0/2000 samples | 0 samples/sRunning... [                                        ] 0% | ETA: 0s | 0/2000 samples | 0 samples/sRunning... [                                        ] 0% | ETA: 0s | 0/2000 samples | 0 samples/sRunning... [■■■■■■■■■■■■■■                          ] 33% | ETA: 1s | 677/2000 samples | 2634 samples/sRunning... [■■■■■■■■■■■■■■                          ] 33% | ETA: 1s | 677/2000 samples | 2634 samples/sRunning... [■■■■■■■■■■■■■■■■■■■■■■■■■■■             ] 66% | ETA: 1s | 1335/2000 samples | 2654 samples/sRunning... [■■■■■■■■■■■■■■■■■■■■■■■■■■■             ] 66% | ETA: 1s | 1335/2000 samples | 2654 samples/sRunning... [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■       ] 82% | ETA: 1s | 1651/2000 samples | 2654 samples/sRunning... [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] 98% | ETA: 1s | 1979/2000 samples | 2653 samples/sAn example execution:

[State 0]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 0,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 1]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 0,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 2]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 0,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 3]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 0,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 4]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 0,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 5]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 1,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 6]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 7]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 8]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 9]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 10]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 11]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "c", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 12]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "c",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 13]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "c",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 14]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("a", "b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "c",
          phase: Busy,
          rss: 1100,
          startRss: 300
        }
    )
}

[State 15]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "a",
          phase: Busy,
          rss: 300,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "c",
          phase: Busy,
          rss: 1100,
          startRss: 300
        }
    )
}

[State 16]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 512,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "a",
          phase: Busy,
          rss: 400,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "c",
          phase: Busy,
          rss: 1100,
          startRss: 300
        }
    )
}

[State 17]
{
  main::scheduler::done: Set(),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 800,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "a",
          phase: Busy,
          rss: 400,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "c",
          phase: Busy,
          rss: 1100,
          startRss: 300
        }
    )
}

[State 18]
{
  main::scheduler::done: Set("c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 784,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "a",
          phase: Busy,
          rss: 400,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Starting,
          rss: 700,
          startRss: 300
        }
    )
}

[State 19]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Starting,
          rss: 350,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Starting,
          rss: 700,
          startRss: 300
        }
    )
}

[State 20]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Starting,
          rss: 350,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Starting,
          rss: 700,
          startRss: 300
        }
    )
}

[State 21]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Starting,
          rss: 350,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Starting,
          rss: 700,
          startRss: 300
        }
    )
}

[State 22]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Idle,
          rss: 350,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Starting,
          rss: 700,
          startRss: 300
        }
    )
}

[State 23]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Idle,
          rss: 350,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Idle,
          rss: 700,
          startRss: 300
        }
    )
}

[State 24]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Idle,
          rss: 350,
          startRss: 300
        },
      1 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Idle,
          rss: 700,
          startRss: 300
        }
    )
}

[State 25]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Idle,
          rss: 350,
          startRss: 300
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Idle,
          rss: 700,
          startRss: 300
        }
    )
}

[State 26]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("b", "fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Idle,
          rss: 350,
          startRss: 300
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "",
          phase: Idle,
          rss: 700,
          startRss: 300
        }
    )
}

[State 27]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("fat", "huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "",
          phase: Idle,
          rss: 350,
          startRss: 300
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 28]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 29]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 30]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 31]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 32]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 33]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 34]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 35]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 36]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 37]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 768,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Busy,
          rss: 2350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 38]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Killed,
          rss: 2350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 700
        }
    )
}

[State 39]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Killed,
          rss: 2350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Busy,
          rss: 1100,
          startRss: 700
        }
    )
}

[State 40]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Killed,
          rss: 2350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Killed,
          rss: 1100,
          startRss: 700
        }
    )
}

[State 41]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Killed,
          rss: 2350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Killed,
          rss: 1100,
          startRss: 700
        }
    )
}

[State 42]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Killed,
          rss: 2350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Killed,
          rss: 1100,
          startRss: 700
        }
    )
}

[State 43]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 350,
          job: "fat",
          phase: Killed,
          rss: 2350,
          startRss: 350
        },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Killed,
          rss: 1100,
          startRss: 700
        }
    )
}

[State 44]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 700,
          job: "b",
          phase: Killed,
          rss: 1100,
          startRss: 700
        }
    )
}

[State 45]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: ["fat", "b"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 46]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat", "b"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 47]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat", "b"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 48]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat", "b"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 49]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat", "b"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 50]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat", "b"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 51]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat", "b"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 52]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "b",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 53]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "b",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 54]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 300
        }
    )
}

[State 55]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 300
        }
    )
}

[State 56]
{
  main::scheduler::done: Set("a", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "b",
          phase: Busy,
          rss: 700,
          startRss: 300
        }
    )
}

[State 57]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 500,
          job: "",
          phase: Starting,
          rss: 500,
          startRss: 300
        }
    )
}

[State 58]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 59]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 60]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 61]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 62]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 63]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 64]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 65]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 66]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        }
    )
}

[State 67]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 68]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 69]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 70]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 71]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 72]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 73]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 74]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["fat"],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 }
    )
}

[State 75]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 76]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 77]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 78]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 79]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 80]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 81]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 82]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 83]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 300,
          startRss: 300
        }
    )
}

[State 84]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 85]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 86]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 87]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 88]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 89]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 90]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 91]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 92]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 93]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 94]
{
  main::scheduler::done: Set("a", "b", "c"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 2000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 300,
          job: "fat",
          phase: Busy,
          rss: 2300,
          startRss: 300
        }
    )
}

[State 95]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "",
          phase: Starting,
          rss: 1300,
          startRss: 300
        }
    )
}

[State 96]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "",
          phase: Idle,
          rss: 1300,
          startRss: 300
        }
    )
}

[State 97]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "",
          phase: Idle,
          rss: 1300,
          startRss: 300
        }
    )
}

[State 98]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "",
          phase: Idle,
          rss: 1300,
          startRss: 300
        }
    )
}

[State 99]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "",
          phase: Idle,
          rss: 1300,
          startRss: 300
        }
    )
}

[State 100]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set("huge"),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "",
          phase: Idle,
          rss: 1300,
          startRss: 300
        }
    )
}

[State 101]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 102]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 103]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 104]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 105]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 106]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 107]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 108]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 109]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 110]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 111]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 112]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 113]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 114]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 115]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 116]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 117]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 118]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 119]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 120]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 121]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 122]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 123]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 1300,
          startRss: 1300
        }
    )
}

[State 124]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 1960,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Busy,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 125]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 126]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 127]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 128]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 129]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 130]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 131]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 132]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 133]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 134]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 135]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 136]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: [],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 ->
        {
          alive: true,
          heap: 1300,
          job: "huge",
          phase: Killed,
          rss: 6300,
          startRss: 1300
        }
    )
}

[State 137]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Parallel,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 138]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 139]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 140]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 141]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 142]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 143]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 144]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 145]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        {
          alive: true,
          heap: 300,
          job: "",
          phase: Starting,
          rss: 300,
          startRss: 0
        },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 146]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 147]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 148]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 149]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[State 150]
{
  main::scheduler::done: Set("a", "b", "c", "fat"),
  main::scheduler::errored: Set(),
  main::scheduler::estimate: 5000,
  main::scheduler::externalKills: 2,
  main::scheduler::mode: Solo,
  main::scheduler::solo: ["huge"],
  main::scheduler::todo: Set(),
  main::scheduler::wasFinished: false,
  main::scheduler::workers:
    Map(
      0 ->
        { alive: true, heap: 300, job: "", phase: Idle, rss: 300, startRss: 0 },
      1 ->
        { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 },
      2 -> { alive: false, heap: 0, job: "", phase: PNone, rss: 0, startRss: 0 }
    )
}

[ok] No violation found (776ms at 2577 traces/second).
Trace length statistics: max=151, min=72, average=132.05
You may increase --max-samples and --max-steps.
Use --verbosity to produce more (or less) output.
Use --seed=0xd7dc5c4760c81948 --backend=rust to reproduce.

  noOomKiller
     noOomKiller::scheduler::onlyHugeErrorsTest [                                        ] 0% | ETA: 0s | 0/200 samples | 0 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■                                   ] 11% | ETA: 1s | 23/200 samples | 230 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■                               ] 23% | ETA: 1s | 46/200 samples | 234 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■■■■■■                          ] 35% | ETA: 1s | 70/200 samples | 236 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■■■■■■■■■■■                     ] 47% | ETA: 1s | 94/200 samples | 236 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■■■■■■■■■■■■■■■■                ] 59% | ETA: 1s | 118/200 samples | 236 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■            ] 71% | ETA: 1s | 142/200 samples | 236 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■       ] 82% | ETA: 1s | 165/200 samples | 236 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■  ] 94% | ETA: 1s | 188/200 samples | 236 samples/s     noOomKiller::scheduler::onlyHugeErrorsTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] 100% | ETA: 0s | 200/200 samples | 236 samples/s     noOomKiller::scheduler::terminatesTest [                                        ] 0% | ETA: 0s | 0/200 samples | 0 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■                                   ] 11% | ETA: 1s | 23/200 samples | 235 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■                               ] 23% | ETA: 1s | 47/200 samples | 235 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■■■■■■                          ] 35% | ETA: 1s | 71/200 samples | 237 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■                     ] 47% | ETA: 1s | 95/200 samples | 238 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■                ] 59% | ETA: 1s | 119/200 samples | 238 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■            ] 71% | ETA: 1s | 142/200 samples | 237 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■       ] 83% | ETA: 1s | 166/200 samples | 238 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■  ] 95% | ETA: 1s | 191/200 samples | 239 samples/s     noOomKiller::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] 100% | ETA: 0s | 200/200 samples | 239 samples/s    ok noOomKiller::scheduler::onlyHugeErrorsTest passed 200 test(s)
    ok noOomKiller::scheduler::terminatesTest passed 200 test(s)

  2 passing (1720ms)

  main
     main::scheduler::terminatesTest [                                        ] 0% | ETA: 0s | 0/200 samples | 0 samples/s     main::scheduler::terminatesTest [■■■■■                                   ] 13% | ETA: 1s | 27/200 samples | 278 samples/s     main::scheduler::terminatesTest [■■■■■■■■■■■                             ] 28% | ETA: 1s | 57/200 samples | 285 samples/s     main::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■                       ] 43% | ETA: 1s | 86/200 samples | 287 samples/s     main::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■                 ] 57% | ETA: 1s | 116/200 samples | 289 samples/s     main::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■           ] 73% | ETA: 1s | 146/200 samples | 291 samples/s     main::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■     ] 88% | ETA: 1s | 176/200 samples | 292 samples/s     main::scheduler::terminatesTest [■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■] 100% | ETA: 0s | 200/200 samples | 293 samples/s    ok main::scheduler::terminatesTest passed 200 test(s)

  1 passing (699ms)