private static int traverseParallel(Node node, CharSequence[] strings,
            int pos, int deep, List<Callable<Object>> jobs) {
        final int BIND_LIMIT = THRESHOLD / SUBBUCKET_THRESHOLD;
        for (char c = 0; c < ALPHABET; c++) {
            int count = node.size(c);
            if (count < 0) {
                pos = traverseParallel((Node) node.get(c), strings, pos,
                        deep + 1, jobs);
            } else if (count > 0) {
                Object[] bind = (Object[]) node.get(c);
                // For the null bucket, copy the elements without sorting.
                if (c == 0) {
                    // If this bucket has a lot of entries, then split it up
                    // into multiple jobs for better parallelism.
                    if (bind.length > BIND_LIMIT) {
                        int offset = 0;
                        int remainder = bind.length % BIND_LIMIT;
                        for (int j = bind.length / BIND_LIMIT; j > 0; j--) {
                            int endoff = offset + BIND_LIMIT;
                            if (remainder == 0 && j == 1) {
                                // This is the end of the bucket, copy only
                                // the number of elements stored therein.
                                jobs.add(new CopySortJob(bind, offset, endoff,
                                        count % THRESHOLD, strings, pos, -1));
                                pos += count % THRESHOLD;
                            } else {
                                jobs.add(new CopySortJob(bind, offset, endoff,
                                        THRESHOLD, strings, pos, -1));
                                pos += THRESHOLD;
                            }
                            offset = endoff;
                        }
                        if (remainder > 0) {
                            jobs.add(new CopySortJob(bind, offset, bind.length,
                                    count % THRESHOLD, strings, pos, -1));
                            pos += count % THRESHOLD;
                        }
                    } else {
                        // Plain and simple copy job.
                        jobs.add(new CopySortJob(bind, 0, bind.length, count,
                                strings, pos, -1));
                        pos += count;
                    }
                } else {
                    // This bucket must be both copied and sorted so we
                    // cannot break it into smaller chunks, but it should
                    // already be less than the threshold size anyway.
                    jobs.add(new CopySortJob(bind, 0, bind.length, count,
                            strings, pos, deep + 1));
                    pos += count;
                }
            }
        }
        return pos;
    }