void beginTask(TraceEntry te) {
      BdynCallback cb = bdyn_factory.getCallback(te.getEntryLocation());
      if (cb == null) return;

      if (trace_writer != null)
        trace_writer.println(
            "PROCESS " + te.getEntryLocation() + " " + te.isExit() + " " + te.getTime());

      if (current_transaction == null) {
        OutputTask ot = null;
        if (te.isExit()) return;
        int i0 = te.getObject1();
        int i1 = te.getObject2();
        if (i0 != 0) {
          ot = object_tasks.get(i0);
          if (ot == dummy_task) ot = null;
        }
        if (ot == null) {
          if (i1 != 0) {
            ot = object_tasks.get(i1);
            if (ot == dummy_task) ot = null;
          }
        }
        if (ot == null) {
          ot = new OutputTask(++task_counter, cb);
        }
        current_transaction = ot;
        nest_level = 0;
      }
      if (!te.isExit()) {
        OutputEntry oe = null;
        if (nest_level == 0) {
          oe = createOutputEntry(te);
        } else if (cb.getCallbackType() == CallbackType.KEY
            && BdynFactory.getOptions().useKeyCallback()) {
          for (int i = output_stack.size() - 1; i >= 0; --i) {
            OutputEntry poe = output_stack.get(i);
            if (poe != null) {
              poe.finishAt(te.getTime());
              if (trace_writer != null)
                trace_writer.println(
                    "FINISHINT "
                        + poe.getEntryTask().getId()
                        + " "
                        + nest_level
                        + " "
                        + poe.getTotalTime(0)
                        + " "
                        + poe.hashCode());
              break;
            }
          }
          oe = createOutputEntry(te);
        } else {
          if (trace_writer != null) trace_writer.println("IGNORE " + cb.getId() + " " + nest_level);
          // System.err.println("TRACE: Ignore " + cb.getDisplayName() + " " + nest_level);
        }
        output_stack.push(oe);
        active_threads.add(this);
        ++nest_level;
      } else {
        if (nest_level <= 0) {
          return;
        }
        --nest_level;
        OutputEntry oe = output_stack.pop();
        if (oe != null) {
          // TODO: max_delta doesn't take into account calls that haven't ended yet
          max_delta = Math.max(max_delta, te.getTime() - oe.getStartTime());
          oe.finishAt(te.getTime());
          if (trace_writer != null)
            trace_writer.println(
                "FINISH "
                    + oe.getEntryTask().getId()
                    + " "
                    + nest_level
                    + " "
                    + oe.getTotalTime(0)
                    + " "
                    + oe.hashCode());
          if (!oe.isRelevant()) {
            output_set.remove(oe);
            if (trace_writer != null)
              trace_writer.println("REMOVE KEY " + oe.getEntryTask().getId() + " " + nest_level);
            // System.err.println("REMOVE KEY " + oe.getEntryTask().getDisplayName());
            oe = null;
            for (int i = output_stack.size() - 1; i >= 0; --i) {
              OutputEntry poe = output_stack.get(i);
              if (poe != null) {
                poe.finishAt(0);
                if (trace_writer != null)
                  trace_writer.println(
                      "NO END "
                          + poe.getEntryTask().getId()
                          + " "
                          + nest_level
                          + " "
                          + poe.hashCode());
                break;
              }
            }
          }
        }

        if (last_entry != null
            && oe != null
            && last_entry.getEntryTask() == oe.getEntryTask()
            && (te.getTime() - last_entry.getStartTime()) < MERGE_TIME) {
          last_entry.mergeWith(oe);
          output_set.remove(oe);
          if (trace_writer != null)
            trace_writer.println("MERGE KEY " + oe.getEntryTask().getId() + " " + nest_level);
          // System.err.println("REMOVE " + oe.getEntryTask().getDisplayName());
        }

        if (oe != null) last_entry = oe;

        if (nest_level == 0) endTask();
        else if (oe != null) {
          for (int i = output_stack.size() - 1; i >= 0; --i) {
            OutputEntry poe = output_stack.get(i);
            if (poe != null) {
              if (!poe.isSignificant()) {
                output_set.remove(poe);
              }
              if (trace_writer != null)
                trace_writer.println(
                    "NEST KEY "
                        + poe.getEntryTask().getId()
                        + " "
                        + nest_level
                        + " "
                        + poe.isSignificant());
              oe = new OutputEntry(te.getTime(), 0, this, current_transaction, poe.getEntryTask());
              oe.setDeletable();
              output_set.add(oe);
              output_stack.set(i, oe);
              break;
            }
          }
        }
      }
    }
  /** ***************************************************************************** */
  void addEntry(String s) {
    // System.err.println("TRACX: " + s);
    if (trace_writer != null) trace_writer.println(s);

    char s0 = s.charAt(0);
    if (s0 == 'T') { // THREAD
      if (thread_entries != null) {
        for (TraceEntry te : thread_entries) pending_entries.add(te);
        thread_entries = null;
      }
      StringTokenizer tok = new StringTokenizer(s);
      tok.nextToken();
      int id = Integer.parseInt(tok.nextToken());
      current_thread = thread_map.get(id);
      if (current_thread == null) {
        int tid = Integer.parseInt(tok.nextToken());
        String tnm = tok.nextToken("\n");
        current_thread = new ThreadData(++thread_counter, tid, tnm);
        thread_map.put(id, current_thread);
      }
      thread_entries = new ArrayList<TraceEntry>();
    } else if (s0 == 'D') { // DONE
      if (trace_writer != null) trace_writer.flush();
      if (thread_entries != null) {
        for (TraceEntry te : thread_entries) pending_entries.add(te);
        thread_entries = null;
      }
      StringTokenizer tok = new StringTokenizer(s);
      tok.nextToken();
      long time = Long.parseLong(tok.nextToken());
      if (next_time != 0) {
        int ct = 0;
        // System.err.println("TRACE: Pending size = " + pending_entries.size());
        while (!pending_entries.isEmpty() && pending_entries.peek().getTime() < next_time) {
          TraceEntry te = pending_entries.remove();
          ++ct;
          outputEntry(te);
        }
        if (ct > 0) {
          for (BdynEventUpdater eu : update_listeners) {
            eu.eventsAdded();
          }
        }
        end_time = Math.max(next_time, end_time);
      }
      next_time = time;
    } else if (s0 == 'S') {
      if (cpu_time == null) {
        StringTokenizer tok = new StringTokenizer(s);
        tok.nextToken();
        cpu_time = Boolean.parseBoolean(tok.nextToken());
      }
    } else if (cpu_time != null) {
      TraceEntry te = new TraceEntry(s, current_thread, cpu_time);
      if (thread_entries == null) pending_entries.add(te);
      else {
        thread_entries.add(te);
        if (te.isExit()) {
          int sz = thread_entries.size();
          int loc = te.getEntryLocation();
          if (sz >= 4) {
            TraceEntry t3 = thread_entries.get(sz - 2);
            if (!t3.isExit() && t3.getEntryLocation() == loc) {
              TraceEntry t2 = thread_entries.get(sz - 3);
              if (t2.isExit() && t2.getEntryLocation() == loc) {
                TraceEntry t1 = thread_entries.get(sz - 4);
                if (!t1.isExit()
                    && t1.getEntryLocation() == loc
                    && (te.getTime() - t1.getTime()) < MERGE_TIME) {
                  t1.merge(t2.getTime(), t3.getTime(), te.getTime());
                  thread_entries.remove(sz - 2);
                  thread_entries.remove(sz - 3);
                }
              }
            }
          }
        }
      }
    }
  }