static class Q {
  BlockingQueue<Runnable> q = new LinkedBlockingQueue;
  
  Q() {}
  
  Q(bool startThread) {
    this("Unnamed Queue", startThread);
  }
  
  Q(String name, boolean startThread) {
    if (startThread)
      startThread(name);
  }
  
  void startThread(S name) {
    new Thread(name) {
      public void run() {
        Q.this.run();
      }
    }.start();
  }
  
  Iterable<Runnable> master() {
    return new Iterable<Runnable>() {
      public Iterator<Runnable> iterator() {
        return new Iterator<Runnable>() {
          Runnable x;
          
          public boolean hasNext() ctex {
            //debug("hasNext");
            while (x == null && licensed())
              x = q.poll(1, TimeUnit.SECONDS);
            //debug("hasNext true");
            return true;
          }
          
          public Runnable next() {
            if (!licensed()) ret null;
            //debug("next");
            hasNext();
            Runnable _x = x;
            x = null;
            //debug("next " + structure(x));
            return _x;
          }
          
          public void remove() {
          }
        };
      }
    };
  }
  
  void add(Runnable r) {
    q.add(r);
  }
  
  void add(O r) {
    q.add(toRunnable(r));
  }
  
  void run() {
    for (Runnable r : master()) {
      if (!licensed()) ret;
      try {
        r.run();
      } catch (Throwable e) {
        e.printStackTrace();
      }
    }
  }
}