anchor.diff:              let paused = multi.ListRangeAsync (this.toKey("paused"), 0L, -1L) 
               do multi.KeyDeleteAsync(this.toKey("wait")) |> ignore
               do multi.KeyDeleteAsync(this.toKey("paused")) |> ignore
  +            do multi.KeyDeleteAsync(this.toKey("meta-paused")) |> ignore
  +            do multi.KeyDeleteAsync(this.toKey("delayed")) |> ignore
               do multi.ExecuteAsync() |> ignore
               
               let jobKeys = Array.concat [|waiting.Result; paused.Result|]
  
positive.code:         }
  
      /// pause the queue
      /// note: (waits for the last job to finish before pausing the queue.)
      /// note 2: (this turns a bit akward when the jobs run in parallel so it might just do two more jobs before it pauses, but it will pause I promise)
      member x.pause () = 
          async {
              logger.Info "pausing queue %s" name
              if paused then 
                  return paused
              else 
                  if processing then 
                      do! this.on.Completed |> Async.AwaitEvent |> Async.Ignore
                  
                  paused <- true
                  do! this.emitQueueEvent Paused 
                  return paused
          }
        
      /// resume a paused queue  
      member x.resume handler = 
          async { 
              logger.Info "resuming queue %s" name
              if paused then
                  paused <- false
                  do! this.emitQueueEvent Resumed
                  this.run handler |> Async.Start
              else
                  failwith "Cannot resume running queue"
          }
  
      /// return the length of the queue
  
negative.code: 
      let newJobChannel = _toKey("jobs") |> keyToChannel 
      let delayedJobChannel = _toKey("delayed") |> keyToChannel 
      let resumedChannel = _toKey("resumed") |> keyToChannel 
      let pausedChannel = _toKey("paused") |> keyToChannel 
  
      let sub = subscriberFactory ()
      do sub.Subscribe(
  