diff --git a/lib/diff/diff.js b/lib/diff/diff.js
index 74bcf6e..4a35723 100644
--- a/lib/diff/diff.js
+++ b/lib/diff/diff.js
@@ -383,23 +383,29 @@ Difference.LCS.traverse_balanced = function(seq1, seq2, callbacks, block) {
   // Ensure that we have at least a default callback object
   callbacks = callbacks != null ? callbacks : new Difference.LCS.BalancedCallbacks();
   // Fetch the matches from the __lcs algorithm
-  var matches = Difference.LCS.__lcs(seq1, seq2);
-  
+  var matches = Difference.LCS.__lcs(seq1, seq2);  
   var a_size = seq1.length;
   var b_size = seq2.length;
-  var ai = 0, bj = 0, mb = 0;
+  var ai = 0, bj = 0;
+  var mb = 0;
   var ma = -1;
   var string = seq1.constructor == String;
   var ax = null, bx = null, event = null;
+  var execute = true;
 
   // Process all the lines in the match vector.
   while(true) {
     // Find next match indices +ma+ and +mb+
-    while(true) {
+    while(execute) {
       ma = ma + 1;
+      // sys.puts(" -- " + !(ma < matches.size && matches[ma] == null))      
       if(!(ma < matches.length && matches[ma] == null)) break;
+      // execute = !(ma < matches.length && matches[ma] == null);
     }
 
+    // sys.puts("ma: " + ma)
+    // sys.puts("====================================== " + (ma < matches.size && matches[ma] == null))
+
     if(ma >= matches.length) break; // end of matches
     mb = matches[ma];
 
@@ -593,12 +599,7 @@ Difference.LCS.__lcs = function(a, b) {
       if(kk != null) links[kk] = [(kk > 0) ? links[kk - 1] : null, ii, jj];
     });
   }
-  
-  // Preinitialize the vector array so we get the nulls at the right points
-  for(var i = 0; i < (a_finish - a_start - 1); i++) {
-    vector[i] = null;
-  }
-  
+    
   // Build the vector
   if(thresh.length > 0) {
     var link = links[thresh.length - 1];
diff --git a/test/diff/test_diff.js b/test/diff/test_diff.js
index ef40ba2..a612824 100644
--- a/test/diff/test_diff.js
+++ b/test/diff/test_diff.js
@@ -45,6 +45,18 @@ var __simple_callbacks = function() {
   return callbacks;
 }
 
+var __balanced_callback = function() {
+  var callback = new Object();
+  callback.result = '';
+  callback.reset = function() { this.result = '' }
+  callback.match = function(event) { this.result += "M" + event.old_position.toString() + event.new_position.toString() + " "; }
+  callback.discard_a = function(event) { this.result += "DA" + event.old_position.toString() + event.new_position.toString() + " "; }
+  callback.discard_b = function(event) { this.result += "DB" + event.old_position.toString() + event.new_position.toString() + " "; }
+  callback.change = function(event) { this.result += "C" + event.old_position.toString() + event.new_position.toString() + " "; }
+  callback.reset();
+  return callback;
+}
+
 var __map_diffs = function(diffs, klass) {
   klass = klass ? klass : Difference.LCS.ContextChange;
   return diffs.map(function(chunks) {
@@ -73,97 +85,97 @@ var __format_diffs = function(diffs) {
 }
 
 suite.addTests({
-  // "Should correctly execute lcs diff":function(assert, finished) {
-  //   var seq1 = ["a", "b", "c", "e", "h", "j", "l", "m", "n", "p"];
-  //   var seq2 = ["b", "c", "d", "e", "f", "j", "k", "l", "m", "r", "s", "t"];
-  //   var correct_lcs = ["b", "c", "e", "j", "l", "m"];
-  //   var res = null
-  //   var ares = [];
-  //   var bres = [];
-  //   
-  //   // Execute lcs over two arrays
-  //   res = Difference.LCS.__lcs(seq1, seq2);
-  //   // The result of the LCS (less the null values) must be as long as the
-  //   // correct result.
-  //   var res_compact = res.filter(function(e) { return e != null;});
-  //   assert.equal(correct_lcs.length, res_compact.length);
-  //   // Check that the values are correct
-  //   for(var i = 0; i < res.length; i++) { assert.ok(res[i] == null || (seq1[i] == seq2[res[i]]));}
-  //   for(var i = 0; i < res.length; i++) { ares[i] = res[i] != null ? seq1[i] : null; }    
-  //   for(var i = 0; i < res.length; i++) { bres[i] = res[i] != null ? seq2[res[i]] : null; }
-  // 
-  //   assert.deepEqual(correct_lcs, ares.filter(function(e) { return e != null; }));
-  //   assert.deepEqual(correct_lcs, bres.filter(function(e) { return e != null; }));
-  //   
-  //   res = Difference.LCS.LCS(seq1, seq2);
-  //   assert.deepEqual(correct_lcs, res.filter(function(e) { return e != null; }));
-  //   finished();
-  // },
-  // 
-  // "Should correctly traverse sequences":function(assert, finished) {
-  //   var seq1 = ["a", "b", "c", "e", "h", "j", "l", "m", "n", "p"];
-  //   var seq2 = ["b", "c", "d", "e", "f", "j", "k", "l", "m", "r", "s", "t"];
-  //   var correct_lcs = ["b", "c", "e", "j", "l", "m"];
-  //   var skipped_seq1 = 'a h n p';
-  //   var skipped_seq2 = 'd f k r s t';
-  //   
-  //   // Let's create a callback object
-  //   var callbacks = __simple_callbacks();
-  //   delete callbacks.finished_a;
-  //   delete callbacks.finished_b;
-  //   // Traverse the sequences
-  //   Difference.LCS.traverse_sequences(seq1, seq2, callbacks);
-  //   assert.equal(correct_lcs.length, callbacks.matched_a.length);
-  //   assert.equal(correct_lcs.length, callbacks.matched_b.length);
-  //   assert.equal(skipped_seq1, callbacks.discards_a.join(" "));
-  //   assert.equal(skipped_seq2, callbacks.discards_b.join(" "));
-  //   
-  //   callbacks = __simple_callbacks();
-  //   Difference.LCS.traverse_sequences(seq1, seq2, callbacks);
-  //   assert.equal(correct_lcs.length, callbacks.matched_a.length);
-  //   assert.equal(correct_lcs.length, callbacks.matched_b.length);
-  //   assert.equal(skipped_seq1, callbacks.discards_a.join(" "));
-  //   assert.equal(skipped_seq2, callbacks.discards_b.join(" "));
-  //   assert.equal(9, callbacks.done_a[0][1]);
-  //   assert.ok(callbacks.done_b[0] == null)
-  //   finished();
-  // },
-  // 
-  // "Should correctly execute diff":function(assert, finished) {
-  //   var seq1 = ["a", "b", "c", "e", "h", "j", "l", "m", "n", "p"];
-  //   var seq2 = ["b", "c", "d", "e", "f", "j", "k", "l", "m", "r", "s", "t"];
-  //   // Correct diff result
-  //   var _correct_diff = [[ [ '-',  0, 'a' ] ], [ [ '+',  2, 'd' ] ], [ [ '-',  4, 'h' ], [ '+',  4, 'f' ] ], [ [ '+',  6, 'k' ] ],
-  //                 [ [ '-',  8, 'n' ], [ '-',  9, 'p' ], [ '+',  9, 'r' ], [ '+', 10, 's' ], [ '+', 11, 't' ] ] ]
-  //   // Map the result
-  //   var correct_diff = __map_diffs(_correct_diff, Difference.LCS.Change);
-  //   var diff = Difference.LCS.diff(seq1, seq2);
-  //   assert.equal(__format_diffs(correct_diff), __format_diffs(diff));
-  //   assert.deepEqual(correct_diff, diff);
-  // 
-  //   finished();
-  // },
-  // 
-  // "Should correctly handle empty diff":function(assert, finished) {
-  //   var seqw = ["abcd", "efgh", "ijkl", "mnopqrstuvwxyz"];
-  //   var correct_diff =  [
-  //                     [ [ '-', 0, 'abcd'           ],
-  //                       [ '-', 1, 'efgh'           ],
-  //                       [ '-', 2, 'ijkl'           ],
-  //                       [ '-', 3, 'mnopqrstuvwxyz' ] ] ];
-  //   
-  //   var diff = Difference.LCS.diff(seqw, []);
-  //   assert.equal(__format_diffs(correct_diff), __format_diffs(diff));
-  //   
-  //   correct_diff = [
-  //                     [ [ '+', 0, 'abcd'           ],
-  //                       [ '+', 1, 'efgh'           ],
-  //                       [ '+', 2, 'ijkl'           ],
-  //                       [ '+', 3, 'mnopqrstuvwxyz' ] ] ];
-  //   diff = Difference.LCS.diff([], seqw);
-  //   assert.equal(__format_diffs(correct_diff), __format_diffs(diff));    
-  //   finished();
-  // },
+  "Should correctly execute lcs diff":function(assert, finished) {
+    var seq1 = ["a", "b", "c", "e", "h", "j", "l", "m", "n", "p"];
+    var seq2 = ["b", "c", "d", "e", "f", "j", "k", "l", "m", "r", "s", "t"];
+    var correct_lcs = ["b", "c", "e", "j", "l", "m"];
+    var res = null
+    var ares = [];
+    var bres = [];
+    
+    // Execute lcs over two arrays
+    res = Difference.LCS.__lcs(seq1, seq2);
+    // The result of the LCS (less the null values) must be as long as the
+    // correct result.
+    var res_compact = res.filter(function(e) { return e != null;});
+    assert.equal(correct_lcs.length, res_compact.length);
+    // Check that the values are correct
+    for(var i = 0; i < res.length; i++) { assert.ok(res[i] == null || (seq1[i] == seq2[res[i]]));}
+    for(var i = 0; i < res.length; i++) { ares[i] = res[i] != null ? seq1[i] : null; }    
+    for(var i = 0; i < res.length; i++) { bres[i] = res[i] != null ? seq2[res[i]] : null; }
+  
+    assert.deepEqual(correct_lcs, ares.filter(function(e) { return e != null; }));
+    assert.deepEqual(correct_lcs, bres.filter(function(e) { return e != null; }));
+    
+    res = Difference.LCS.LCS(seq1, seq2);
+    assert.deepEqual(correct_lcs, res.filter(function(e) { return e != null; }));
+    finished();
+  },
+  
+  "Should correctly traverse sequences":function(assert, finished) {
+    var seq1 = ["a", "b", "c", "e", "h", "j", "l", "m", "n", "p"];
+    var seq2 = ["b", "c", "d", "e", "f", "j", "k", "l", "m", "r", "s", "t"];
+    var correct_lcs = ["b", "c", "e", "j", "l", "m"];
+    var skipped_seq1 = 'a h n p';
+    var skipped_seq2 = 'd f k r s t';
+    
+    // Let's create a callback object
+    var callbacks = __simple_callbacks();
+    delete callbacks.finished_a;
+    delete callbacks.finished_b;
+    // Traverse the sequences
+    Difference.LCS.traverse_sequences(seq1, seq2, callbacks);
+    assert.equal(correct_lcs.length, callbacks.matched_a.length);
+    assert.equal(correct_lcs.length, callbacks.matched_b.length);
+    assert.equal(skipped_seq1, callbacks.discards_a.join(" "));
+    assert.equal(skipped_seq2, callbacks.discards_b.join(" "));
+    
+    callbacks = __simple_callbacks();
+    Difference.LCS.traverse_sequences(seq1, seq2, callbacks);
+    assert.equal(correct_lcs.length, callbacks.matched_a.length);
+    assert.equal(correct_lcs.length, callbacks.matched_b.length);
+    assert.equal(skipped_seq1, callbacks.discards_a.join(" "));
+    assert.equal(skipped_seq2, callbacks.discards_b.join(" "));
+    assert.equal(9, callbacks.done_a[0][1]);
+    assert.ok(callbacks.done_b[0] == null)
+    finished();
+  },
+  
+  "Should correctly execute diff":function(assert, finished) {
+    var seq1 = ["a", "b", "c", "e", "h", "j", "l", "m", "n", "p"];
+    var seq2 = ["b", "c", "d", "e", "f", "j", "k", "l", "m", "r", "s", "t"];
+    // Correct diff result
+    var _correct_diff = [[ [ '-',  0, 'a' ] ], [ [ '+',  2, 'd' ] ], [ [ '-',  4, 'h' ], [ '+',  4, 'f' ] ], [ [ '+',  6, 'k' ] ],
+                  [ [ '-',  8, 'n' ], [ '-',  9, 'p' ], [ '+',  9, 'r' ], [ '+', 10, 's' ], [ '+', 11, 't' ] ] ]
+    // Map the result
+    var correct_diff = __map_diffs(_correct_diff, Difference.LCS.Change);
+    var diff = Difference.LCS.diff(seq1, seq2);
+    assert.equal(__format_diffs(correct_diff), __format_diffs(diff));
+    assert.deepEqual(correct_diff, diff);
+  
+    finished();
+  },
+  
+  "Should correctly handle empty diff":function(assert, finished) {
+    var seqw = ["abcd", "efgh", "ijkl", "mnopqrstuvwxyz"];
+    var correct_diff =  [
+                      [ [ '-', 0, 'abcd'           ],
+                        [ '-', 1, 'efgh'           ],
+                        [ '-', 2, 'ijkl'           ],
+                        [ '-', 3, 'mnopqrstuvwxyz' ] ] ];
+    
+    var diff = Difference.LCS.diff(seqw, []);
+    assert.equal(__format_diffs(correct_diff), __format_diffs(diff));
+    
+    correct_diff = [
+                      [ [ '+', 0, 'abcd'           ],
+                        [ '+', 1, 'efgh'           ],
+                        [ '+', 2, 'ijkl'           ],
+                        [ '+', 3, 'mnopqrstuvwxyz' ] ] ];
+    diff = Difference.LCS.diff([], seqw);
+    assert.equal(__format_diffs(correct_diff), __format_diffs(diff));    
+    finished();
+  },
   
   "Should correctly execute sdiff_a":function(assert, finished) {
     var seq1 = ["abc", "def", "yyy", "xxx", "ghi", "jkl"];
@@ -177,21 +189,318 @@ suite.addTests({
                     [ '=', [ 5, 'jkl' ], [ 4, 'jkl' ] ] ];
                     
     var correct_sdiff = __map_diffs(correct_sdiff);
-    // sys.puts("========================================== CORRECT SDIFF")
-    // correct_sdiff.forEach(function(f) {
-    //   sys.puts(sys.inspect(f.to_a()))
-    // });
     var sdiff = Difference.LCS.sdiff(seq1, seq2);    
-    // sys.puts("========================================== SDIFF")
-    // sdiff.forEach(function(f) {
-    //   sys.puts(sys.inspect(f.to_a()))
-    // });
     assert.deepEqual(correct_sdiff, sdiff);
     finished();
-  }
+  },
+  
+  "Should correctly execute sdiff_b":function(assert, finished) {
+    var seq1 = ["a", "b", "c", "e", "h", "j", "l", "m", "n", "p"];
+    var seq2 = ["b", "c", "d", "e", "f", "j", "k", "l", "m", "r", "s", "t"];
+    var correct_sdiff = [
+                [ '-', [  0, 'a' ], [  0, null ] ],
+                [ '=', [  1, 'b' ], [  0, 'b' ] ],
+                [ '=', [  2, 'c' ], [  1, 'c' ] ],
+                [ '+', [  3, null ], [  2, 'd' ] ],
+                [ '=', [  3, 'e' ], [  3, 'e' ] ],
+                [ '!', [  4, 'h' ], [  4, 'f' ] ],
+                [ '=', [  5, 'j' ], [  5, 'j' ] ],
+                [ '+', [  6, null ], [  6, 'k' ] ],
+                [ '=', [  6, 'l' ], [  7, 'l' ] ],
+                [ '=', [  7, 'm' ], [  8, 'm' ] ],
+                [ '!', [  8, 'n' ], [  9, 'r' ] ],
+                [ '!', [  9, 'p' ], [ 10, 's' ] ],
+                [ '+', [ 10, null ], [ 11, 't' ] ] ];
+      
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly execute sdiff_c":function(assert, finished) {
+    var seq1 = ["a", "b", "c", "d", "e"];
+    var seq2 = ["a", "e"];
+    var correct_sdiff = [
+                [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
+                [ '-', [ 1, 'b' ], [ 1, null ] ],
+                [ '-', [ 2, 'c' ], [ 1, null ] ],
+                [ '-', [ 3, 'd' ], [ 1, null ] ],
+                [ '=', [ 4, 'e' ], [ 1, 'e' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+      
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();    
+  },
+  
+  "Should correctly test sdiff_d":function(assert, finished) {
+    var seq1 = ["a", "e"];
+    var seq2 = ["a", "b", "c", "d", "e"];
+    var correct_sdiff = [
+                  [ '=', [ 0, 'a' ], [ 0, 'a' ] ],
+                  [ '+', [ 1, null ], [ 1, 'b' ] ],
+                  [ '+', [ 1, null ], [ 2, 'c' ] ],
+                  [ '+', [ 1, null ], [ 3, 'd' ] ],
+                  [ '=', [ 1, 'e' ], [ 4, 'e' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_e":function(assert, finished) {
+    var seq1 = ["v", "x", "a", "e"];
+    var seq2 = ["w", "y", "a", "b", "c", "d", "e"];
+    var correct_sdiff = [
+                    [ '!', [ 0, 'v' ], [ 0, 'w' ] ],
+                    [ '!', [ 1, 'x' ], [ 1, 'y' ] ],
+                    [ '=', [ 2, 'a' ], [ 2, 'a' ] ],
+                    [ '+', [ 3, null ], [ 3, 'b' ] ],
+                    [ '+', [ 3, null ], [ 4, 'c' ] ],
+                    [ '+', [ 3, null ], [ 5, 'd' ] ],
+                    [ '=', [ 3, 'e' ], [ 6, 'e' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_f":function(assert, finished) {
+    var seq1 = ["x", "a", "e"];
+    var seq2 = ["a", "b", "c", "d", "e"];
+    var correct_sdiff = [
+                      [ '-', [ 0, 'x' ], [ 0, null ] ],
+                      [ '=', [ 1, 'a' ], [ 0, 'a' ] ],
+                      [ '+', [ 2, null ], [ 1, 'b' ] ],
+                      [ '+', [ 2, null ], [ 2, 'c' ] ],
+                      [ '+', [ 2, null ], [ 3, 'd' ] ],
+                      [ '=', [ 2, 'e' ], [ 4, 'e' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_g":function(assert, finished) {
+    var seq1 = ["a", "e"];
+    var seq2 = ["x", "a", "b", "c", "d", "e"];
+    var correct_sdiff = [
+                      [ '+', [ 0, null ], [ 0, 'x' ] ],
+                      [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
+                      [ '+', [ 1, null ], [ 2, 'b' ] ],
+                      [ '+', [ 1, null ], [ 3, 'c' ] ],
+                      [ '+', [ 1, null ], [ 4, 'd' ] ],
+                      [ '=', [ 1, 'e' ], [ 5, 'e' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_h":function(assert, finished) {
+    var seq1 = ["a", "e", "v"];
+    var seq2 = ["x", "a", "b", "c", "d", "e", "w", "x"];
+    var correct_sdiff = [
+                      [ '+', [ 0, null ], [ 0, 'x' ] ],
+                      [ '=', [ 0, 'a' ], [ 1, 'a' ] ],
+                      [ '+', [ 1, null ], [ 2, 'b' ] ],
+                      [ '+', [ 1, null ], [ 3, 'c' ] ],
+                      [ '+', [ 1, null ], [ 4, 'd' ] ],
+                      [ '=', [ 1, 'e' ], [ 5, 'e' ] ],
+                      [ '!', [ 2, 'v' ], [ 6, 'w' ] ],
+                      [ '+', [ 3, null ], [ 7, 'x' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_i":function(assert, finished) {
+    var seq1 = [];
+    var seq2 = ["a", "b", "c"];
+    var correct_sdiff = [
+                      [ '+', [ 0, null ], [ 0, 'a' ] ],
+                      [ '+', [ 0, null ], [ 1, 'b' ] ],
+                      [ '+', [ 0, null ], [ 2, 'c' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_j":function(assert, finished) {
+    var seq1 = ["a", "b", "c"];
+    var seq2 = [];
+    var correct_sdiff = [
+                      [ '-', [ 0, 'a' ], [ 0, null ] ],
+                      [ '-', [ 1, 'b' ], [ 0, null ] ],
+                      [ '-', [ 2, 'c' ], [ 0, null ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_k":function(assert, finished) {
+    var seq1 = ["a", "b", "c"];
+    var seq2 = ["1"];
+    var correct_sdiff = [
+                      [ '!', [ 0, 'a' ], [ 0, '1' ] ],
+                      [ '-', [ 1, 'b' ], [ 1, null ] ],
+                      [ '-', [ 2, 'c' ], [ 1, null ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_l":function(assert, finished) {
+    var seq1 = ["a", "b", "c"];
+    var seq2 = ["c"];
+    var correct_sdiff = [
+                      [ '-', [ 0, 'a' ], [ 0, null ] ],
+                      [ '-', [ 1, 'b' ], [ 0, null ] ],
+                      [ '=', [ 2, 'c' ], [ 0, 'c' ] ]];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_m":function(assert, finished) {
+    var seq1 = ["abcd", "efgh", "ijkl", "mnop"];
+    var seq2 = [];
+    var correct_sdiff = [
+                      [ '-', [ 0, 'abcd' ], [ 0, null ] ],
+                      [ '-', [ 1, 'efgh' ], [ 0, null ] ],
+                      [ '-', [ 2, 'ijkl' ], [ 0, null ] ],
+                      [ '-', [ 3, 'mnop' ], [ 0, null ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test sdiff_n":function(assert, finished) {
+    var seq1 = [];
+    var seq2 = ["abcd", "efgh", "ijkl", "mnop"];
+    var correct_sdiff = [
+                      [ '+', [ 0, null ], [ 0, 'abcd' ] ],
+                      [ '+', [ 0, null ], [ 1, 'efgh' ] ],
+                      [ '+', [ 0, null ], [ 2, 'ijkl' ] ],
+                      [ '+', [ 0, null ], [ 3, 'mnop' ] ] ];
+    correct_sdiff = __map_diffs(correct_sdiff);
+    var sdiff = Difference.LCS.sdiff(seq1, seq2);
+    assert.deepEqual(correct_sdiff, sdiff);
+    finished();
+  },
+  
+  "Should correctly test balanced a":function(assert, finished) {
+    var seq1 = ["a", "b", "c"];
+    var seq2 = ["a", "x", "c"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("M00 C11 M22 ", callback.result);
+    finished();
+  },
+  
+  "Should correctly test balanced b":function(assert, finished) {
+    var seq1 = ["a", "b", "c"];
+    var seq2 = ["a", "x", "c"];
+    var callback = __balanced_callback();
+    // Remove the method change
+    delete callback.change;
+    
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("M00 DA11 DB21 M22 ", callback.result);
+    finished();
+  },
+  
+  "Should correctly test balanced c":function(assert, finished) {
+    var seq1 = ["a", "x", "y", "c"];
+    var seq2 = ["a", "v", "w", "c"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("M00 C11 C22 M33 ", callback.result);
+    finished();
+  },
+  
+  "Should correctly test balanced d":function(assert, finished) {
+    var seq1 = ["x", "y", "c"];
+    var seq2 = ["v", "w", "c"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("C00 C11 M22 ", callback.result);
+    finished();
+  },
+  
+  "Should correctly test balanced e":function(assert, finished) {
+    var seq1 = ["a", "x", "y", "z"];
+    var seq2 = ["b", "v", "w"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("C00 C11 C22 DA33 ", callback.result);
+    finished();
+  },
+
+  "Should correctly test balanced f":function(assert, finished) {
+    var seq1 = ["a", "z"];
+    var seq2 = ["a"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("M00 DA11 ", callback.result);
+    finished();
+  },
+
+  "Should correctly test balanced g":function(assert, finished) {
+    var seq1 = ["z", "a"];
+    var seq2 = ["a"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("DA00 M10 ", callback.result);
+    finished();
+  },
+
+  "Should correctly test balanced h":function(assert, finished) {
+    var seq1 = ["a", "b", "c"];
+    var seq2 = ["x", "y", "z"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("C00 C11 C22 ", callback.result);
+    finished();
+  },
+
+  "Should correctly test balanced i":function(assert, finished) {
+    var seq1 = ["abcd", "efgh", "ijkl", "mnopqrstuvwxyz"];
+    var seq2 = [];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("DA00 DA10 DA20 DA30 ", callback.result);
+    finished();
+  },
+
+  "Should correctly test balanced j":function(assert, finished) {
+    var seq1 = [];
+    var seq2 = ["abcd", "efgh", "ijkl", "mnopqrstuvwxyz"];
+    var callback = __balanced_callback();
+    Difference.LCS.traverse_balanced(seq1, seq2, callback);
+    assert.equal("DB00 DB01 DB02 DB03 ", callback.result);
+    finished();
+  },
 
 });
 
+// sys.puts("========================================== CORRECT SDIFF")
+// correct_sdiff.forEach(function(f) {
+//   sys.puts(sys.inspect(f.to_a()))
+// });
+// sys.puts("========================================== SDIFF")
+// sdiff.forEach(function(f) {
+//   sys.puts(sys.inspect(f.to_a()))
+// });    
+
+