--- a/compare_locales/compare.py
+++ b/compare_locales/compare.py
@@ -111,27 +111,29 @@ class Tree(object):
 
 
 class AddRemove(object):
     def __init__(self, key=None):
         self.left = self.right = None
         self.key = key
 
     def set_left(self, left):
-        if not isinstance(left, set):
-            left = set(l for l in left)
+        if not isinstance(left, list):
+            left = list(l for l in left)
         self.left = left
 
     def set_right(self, right):
-        if not isinstance(right, set):
-            right = set(l for l in right)
+        if not isinstance(right, list):
+            right = list(l for l in right)
         self.right = right
 
     def __iter__(self):
-        for item in sorted(self.left | self.right, key=self.key):
+        all_items = self.left[:]
+        all_items.extend(k for k in self.right if k not in self.left)
+        for item in sorted(all_items, key=self.key):
             if item in self.left and item in self.right:
                 yield ('equal', item)
             elif item in self.left:
                 yield ('delete', item)
             else:
                 yield ('add', item)
 
 
@@ -316,16 +318,29 @@ class Observer(object):
                         0) / total
             out.append('%d%% of entries changed' % rate)
         return '\n'.join(map(tostr, self.details.getContent()) + out)
 
     def __str__(self):
         return 'observer'
 
 
+class indexof(object):
+    def __init__(self, ref_map):
+        self.ref_map = ref_map
+        self.off = [-1, 0]
+
+    def __call__(self, key):
+        if key in self.ref_map:
+            self.off = [self.ref_map[key], 0]
+        else:
+            self.off[1] += 1
+        return self.off
+
+
 class ContentComparer:
     keyRE = re.compile('[kK]ey')
     nl = re.compile('\n', re.M)
 
     def __init__(self, observers, stat_observers=None):
         '''Create a ContentComparer.
         observer is usually a instance of Observer. The return values
         of the notify method are used to control the handling of missing
@@ -422,29 +437,27 @@ class ContentComparer:
             # no comparison, XXX report?
             return
         try:
             p.readContents(ref_file.getContents())
         except Exception, e:
             self.notify('error', ref_file, str(e))
             return
         ref = p.parse()
-        ref_list = ref[1].keys()
-        ref_list.sort()
+        ref_list = sorted(ref[1].keys(), key=lambda k: ref[1][k])
         try:
             p.readContents(l10n.getContents())
             l10n_entities, l10n_map = p.parse()
             l10n_ctx = p.ctx
         except Exception, e:
             self.notify('error', l10n, str(e))
             return
 
-        l10n_list = l10n_map.keys()
-        l10n_list.sort()
-        ar = AddRemove()
+        l10n_list = sorted(l10n_map.keys(), key=lambda k: l10n_map[k])
+        ar = AddRemove(key=indexof(ref[1]))
         ar.set_left(ref_list)
         ar.set_right(l10n_list)
         report = missing = obsolete = changed = unchanged = keys = 0
         missing_w = changed_w = unchanged_w = 0  # word stats
         missings = []
         skips = []
         checker = getChecker(l10n, reference=ref[0], extra_tests=extra_tests)
         for action, entity in ar:

--- a/compare_locales/tests/test_merge.py
+++ b/compare_locales/tests/test_merge.py
@@ -80,26 +80,26 @@ eff = effVal""")
                 {None: {
                     'changed': 1,
                     'changed_w': 1,
                     'missing': 2,
                     'missing_w': 2
                 }},
              'details': {
                  'l10n.properties': [
-                     {'missingEntity': u'eff'},
-                     {'missingEntity': u'foo'}]
+                     {'missingEntity': u'foo'},
+                     {'missingEntity': u'eff'}]
                 }
              })
         mergefile = mozpath.join(self.tmp, "merge", "l10n.properties")
         self.assertTrue(os.path.isfile(mergefile))
         p = getParser(mergefile)
         p.readFile(mergefile)
         [m, n] = p.parse()
-        self.assertEqual(map(lambda e: e.key,  m), ["bar", "eff", "foo"])
+        self.assertEqual(map(lambda e: e.key,  m), ["bar", "foo", "eff"])
 
     def testError(self):
         self.assertTrue(os.path.isdir(self.tmp))
         self.reference("""foo = fooVal
 bar = %d barVal
 eff = effVal""")
         self.localized("""\
 bar = %S lBar
@@ -116,19 +116,19 @@ eff = leffVal
                     'changed': 2,
                     'changed_w': 3,
                     'errors': 1,
                     'missing': 1,
                     'missing_w': 1
                 }},
              'details': {
                  'l10n.properties': [
+                     {'missingEntity': u'foo'},
                      {'error': u'argument 1 `S` should be `d` '
-                               u'at line 1, column 7 for bar'},
-                     {'missingEntity': u'foo'}]
+                               u'at line 1, column 7 for bar'}]
                 }
              })
         mergefile = mozpath.join(self.tmp, "merge", "l10n.properties")
         self.assertTrue(os.path.isfile(mergefile))
         p = getParser(mergefile)
         p.readFile(mergefile)
         [m, n] = p.parse()
         self.assertEqual([e.key for e in m], ["eff", "foo", "bar"])
@@ -218,26 +218,26 @@ class TestDTD(unittest.TestCase, Content
                 {None: {
                     'changed': 1,
                     'changed_w': 1,
                     'missing': 2,
                     'missing_w': 2
                 }},
              'details': {
                  'l10n.dtd': [
-                     {'missingEntity': u'eff'},
-                     {'missingEntity': u'foo'}]
+                     {'missingEntity': u'foo'},
+                     {'missingEntity': u'eff'}]
                 }
              })
         mergefile = mozpath.join(self.tmp, "merge", "l10n.dtd")
         self.assertTrue(os.path.isfile(mergefile))
         p = getParser(mergefile)
         p.readFile(mergefile)
         [m, n] = p.parse()
-        self.assertEqual(map(lambda e: e.key,  m), ["bar", "eff", "foo"])
+        self.assertEqual(map(lambda e: e.key,  m), ["bar", "foo", "eff"])
 
     def testJunk(self):
         self.assertTrue(os.path.isdir(self.tmp))
         self.reference("""<!ENTITY foo 'fooVal'>
 <!ENTITY bar 'barVal'>
 <!ENTITY eff 'effVal'>""")
         self.localized("""<!ENTITY foo 'fooVal'>
 <!ENTY bar 'gimmick'>
@@ -254,21 +254,21 @@ class TestDTD(unittest.TestCase, Content
                     'errors': 1,
                     'missing': 1,
                     'missing_w': 1,
                     'unchanged': 2,
                     'unchanged_w': 2
                 }},
              'details': {
                  'l10n.dtd': [
+                     {'missingEntity': u'bar'},
                      {'error': u'Unparsed content "<!ENTY bar '
                                u'\'gimmick\'>" '
                                u'from line 2 column 1 to '
-                               u'line 2 column 22'},
-                     {'missingEntity': u'bar'}]
+                               u'line 2 column 22'}]
                 }
              })
         mergefile = mozpath.join(self.tmp, "merge", "l10n.dtd")
         self.assertTrue(os.path.isfile(mergefile))
         p = getParser(mergefile)
         p.readFile(mergefile)
         [m, n] = p.parse()
         self.assertEqual(map(lambda e: e.key,  m), ["foo", "eff", "bar"])