             int binary_work_est = u_len*log_v;
             int intersect_work_est = u_len + v_len;
             //const int WORK_FACTOR = 100;
-            const int WORK_FACTOR = 0; // force balanced-only
+            const int WORK_FACTOR = 9999; // force balanced-only
             int METHOD = (WORK_FACTOR*intersect_work_est >= binary_work_est);
             bin_index = (METHOD*MAX_ADJ_UNIONS_BINS/2)+(log_u*BINS_1D_DIM+log_v); 
             //bin_index = MAX_ADJ_UNIONS_BINS/2+((src.id() + dst.id())%(MAX_ADJ_UNIONS_BINS/2));

            TM.reset();
        }
        start_index = end_index;
        log_factor += 1;
    }
    */
    free(queue_sizes);
    free(queue_pos);
}

        TM.print("balanced queue processing:");
        TM.reset();
    }

    // imbalanced kernel
    const int LOG_OFFSET2 = 2;
    const int IMBALANCED_THREADS_LOGMAX = BINS_1D_DIM-1; 
    bin_offset = MAX_ADJ_UNIONS_BINS/2;
    threads_log = 1;
    while ((threads_log < IMBALANCED_THREADS_LOGMAX) && (threads_log+LOG_OFFSET2 < BINS_1D_DIM)) 
    {
        bin_index = bin_offset+(threads_log+LOG_OFFSET2)*BINS_1D_DIM;
        end_index = queue_pos[bin_index];
        size = end_index - start_index;
        if (size) {
            printf("(start_index, end_index): %d, %d\n", start_index, end_index);
            printf("threads_log, bin_index: %d, %d\n", threads_log, bin_index);
            threads_per = 1 << (threads_log-1); 
            printf("threads_per: %d, size: %d\n", threads_per, size);
            TM.start();
            forAllEdgesAdjUnionImbalanced(hornet, hd_queue_info().d_edge_queue, start_index, end_index, op, threads_per, 1);
            TM.stop();
