#
#
# patch "cset.cc"
#  from [d798f6b6759226d803c16118d35f8bda4b31bbb7]
#    to [ee0aba985f36fe78699987b4ea2cf6d9dc870a68]
# 
# patch "roster.cc"
#  from [1d508653551de89ff92e579572bb4f810b067e9c]
#    to [e3ca6a3e83c2e272ff2be662667a73fd3b6ea6b6]
# 
# patch "roster_delta.cc"
#  from [1c7bb6d30b4a3701b962bab9e8956881f0a4fcea]
#    to [88f180cd499cf6894014d8fee8a708592358b946]
# 
# patch "roster_merge.cc"
#  from [d565f9299ca85d77bd1d7f2a29196d7161f0ea08]
#    to [343c0bf5bbb143432954a86f0174a7a5bc76402e]
#
============================================================
--- cset.cc	d798f6b6759226d803c16118d35f8bda4b31bbb7
+++ cset.cc	ee0aba985f36fe78699987b4ea2cf6d9dc870a68
@@ -15,6 +15,7 @@
 #include "cset.hh"
 #include "sanity.hh"
 #include "safe_map.hh"
+#include "transforms.hh"
 
 using std::set;
 using std::map;
@@ -393,7 +394,7 @@ parse_cset(basic_io::parser & parser,
       prev_path = p1;
       parser.esym(syms::content);
       parser.hex(t1);
-      safe_insert(cs.files_added, make_pair(p1, file_id(t1)));
+      safe_insert(cs.files_added, make_pair(p1, file_id(decode_hexenc(t1))));
     }
 
   prev_path.clear();
@@ -408,7 +409,8 @@ parse_cset(basic_io::parser & parser,
       parser.esym(syms::to);
       parser.hex(t2);
       safe_insert(cs.deltas_applied,
-                  make_pair(p1, make_pair(file_id(t1), file_id(t2))));
+                  make_pair(p1, make_pair(file_id(decode_hexenc(t1)),
+                                          file_id(decode_hexenc(t2)))));
     }
 
   prev_pair.first.clear();
============================================================
--- roster.cc	1d508653551de89ff92e579572bb4f810b067e9c
+++ roster.cc	e3ca6a3e83c2e272ff2be662667a73fd3b6ea6b6
@@ -74,7 +74,7 @@ dump(set<revision_id> const & revids, st
       if (!first)
         out += ", ";
       first = false;
-      out += i->inner()();
+      out += encode_hexenc(i->inner()());
     }
 }
 
@@ -83,7 +83,7 @@ dump(marking_t const & marking, string &
 {
   ostringstream oss;
   string tmp;
-  oss << "birth_revision: " << marking.birth_revision << '\n';
+  oss << "birth_revision: " << encode_hexenc(marking.birth_revision.inner()()) << '\n';
   dump(marking.parent_name, tmp);
   oss << "parent_name: " << tmp << '\n';
   dump(marking.file_content, tmp);
@@ -265,8 +265,12 @@ dump(node_t const & n, string & out)
   oss << "attrs:\n" << attr_map_s;
   oss << "type: ";
   if (is_file_t(n))
-    oss << "file\n"
-        << "content: " << downcast_to_file_t(n)->content << '\n';
+    {
+      string fcontent = decode_hexenc(
+        downcast_to_file_t(n)->content.inner()());
+      oss << "file\n"
+          << "content: " << fcontent << '\n';
+    }
   else
     {
       oss << "dir\n";
@@ -2506,19 +2510,19 @@ parse_marking(basic_io::parser & pa,
         {
           pa.sym();
           pa.hex(rev);
-          marking.birth_revision = revision_id(rev);
+          marking.birth_revision = revision_id(decode_hexenc(rev));
         }
       else if (pa.symp(basic_io::syms::path_mark))
         {
           pa.sym();
           pa.hex(rev);
-          safe_insert(marking.parent_name, revision_id(rev));
+          safe_insert(marking.parent_name, revision_id(decode_hexenc(rev)));
         }
       else if (pa.symp(basic_io::syms::content_mark))
         {
           pa.sym();
           pa.hex(rev);
-          safe_insert(marking.file_content, revision_id(rev));
+          safe_insert(marking.file_content, revision_id(decode_hexenc(rev)));
         }
       else if (pa.symp(basic_io::syms::attr_mark))
         {
@@ -2527,7 +2531,7 @@ parse_marking(basic_io::parser & pa,
           pa.str(k);
           pa.hex(rev);
           attr_key key = attr_key(k);
-          safe_insert(marking.attrs[key], revision_id(rev));
+          safe_insert(marking.attrs[key], revision_id(decode_hexenc(rev)));
         }
       else break;
     }
@@ -2662,7 +2666,7 @@ roster_t::parse_from(basic_io::parser & 
           pa.esym(basic_io::syms::ident);
           pa.str(ident);
           n = file_t(new file_node(read_num(ident),
-                                   file_id(content)));
+                                   file_id(decode_hexenc(content))));
         }
       else if (pa.symp(basic_io::syms::dir))
         {
@@ -2804,7 +2808,7 @@ make_fake_marking_for(roster_t const & r
 make_fake_marking_for(roster_t const & r, marking_map & mm)
 {
   mm.clear();
-  revision_id rid(string("0123456789abcdef0123456789abcdef01234567"));
+  revision_id rid(decode_hexenc("0123456789abcdef0123456789abcdef01234567"));
   for (node_map::const_iterator i = r.all_nodes().begin(); i != r.all_nodes().end();
        ++i)
     {
@@ -3021,7 +3025,7 @@ file_id new_ident(randomizer & rng)
   tmp.reserve(constants::idlen);
   for (unsigned i = 0; i < constants::idlen; ++i)
     tmp += tab[rng.uniform(tab.size())];
-  return file_id(tmp);
+  return file_id(decode_hexenc(tmp));
 }
 
 path_component new_component(randomizer & rng)
@@ -3288,7 +3292,7 @@ check_sane_roster_do_tests(int to_run, i
   file_path fp_foo_bar = file_path_internal("foo/bar");
   file_path fp_foo_baz = file_path_internal("foo/baz");
 
-  node_id nid_f = r.create_file_node(file_id(string("0000000000000000000000000000000000000000")),
+  node_id nid_f = r.create_file_node(file_id(decode_hexenc("0000000000000000000000000000000000000000")),
                                      nis);
   // root must be a directory, not a file
   MAYBE(UNIT_TEST_CHECK_THROW(r.attach_node(nid_f, fp_), logic_error));
@@ -3496,10 +3500,10 @@ namespace
     return s;
   }
 
-  revision_id old_rid(string("0000000000000000000000000000000000000000"));
-  revision_id left_rid(string("1111111111111111111111111111111111111111"));
-  revision_id right_rid(string("2222222222222222222222222222222222222222"));
-  revision_id new_rid(string("4444444444444444444444444444444444444444"));
+  revision_id old_rid(decode_hexenc("0000000000000000000000000000000000000000"));
+  revision_id left_rid(decode_hexenc("1111111111111111111111111111111111111111"));
+  revision_id right_rid(decode_hexenc("2222222222222222222222222222222222222222"));
+  revision_id new_rid(decode_hexenc("4444444444444444444444444444444444444444"));
 
 ////////////////
 // These classes encapsulate information about all the different scalars
@@ -3571,7 +3575,7 @@ namespace
                          roster_t & roster, marking_map & markings)
     {
       make_file(scalar_origin_rid, nid,
-                file_id(string("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")),
+                file_id(decode_hexenc("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")),
                 roster, markings);
     }
     static void make_file(revision_id const & scalar_origin_rid, node_id nid,
@@ -3609,13 +3613,13 @@ namespace
     {
       safe_insert(values,
                   make_pair(scalar_a,
-                            file_id(string("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))));
+                            file_id(decode_hexenc("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))));
       safe_insert(values,
                   make_pair(scalar_b,
-                            file_id(string("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))));
+                            file_id(decode_hexenc("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))));
       safe_insert(values,
                   make_pair(scalar_c,
-                            file_id(string("cccccccccccccccccccccccccccccccccccccccc"))));
+                            file_id(decode_hexenc("cccccccccccccccccccccccccccccccccccccccc"))));
     }
     virtual void
     set(revision_id const & scalar_origin_rid, scalar_val val,
@@ -4489,8 +4493,8 @@ UNIT_TEST(roster, write_roster)
   file_path fo = file_path_internal("fo");
   file_path xx = file_path_internal("xx");
 
-  file_id f1(string("1111111111111111111111111111111111111111"));
-  revision_id rid(string("1234123412341234123412341234123412341234"));
+  file_id f1(decode_hexenc("1111111111111111111111111111111111111111"));
+  revision_id rid(decode_hexenc("1234123412341234123412341234123412341234"));
   node_id nid;
 
   // if adding new nodes, add them at the end to keep the node_id order
@@ -4631,8 +4635,8 @@ UNIT_TEST(roster, check_sane_against)
   file_path foo = file_path_internal("foo");
   file_path bar = file_path_internal("bar");
 
-  file_id f1(string("1111111111111111111111111111111111111111"));
-  revision_id rid(string("1234123412341234123412341234123412341234"));
+  file_id f1(decode_hexenc("1111111111111111111111111111111111111111"));
+  revision_id rid(decode_hexenc("1234123412341234123412341234123412341234"));
   node_id nid;
 
   {
@@ -4931,7 +4935,7 @@ UNIT_TEST(roster, unify_rosters_end_to_e
   L(FL("TEST: begin checking unification of rosters (end to end, ids)"));
   revision_id has_rid = left_rid;
   revision_id has_not_rid = right_rid;
-  file_id my_fid(string("9012901290129012901290129012901290129012"));
+  file_id my_fid(decode_hexenc("9012901290129012901290129012901290129012"));
 
   testing_node_id_source nis;
 
@@ -5010,7 +5014,7 @@ UNIT_TEST(roster, unify_rosters_end_to_e
   L(FL("TEST: begin checking unification of rosters (end to end, attr corpses)"));
   revision_id first_rid = left_rid;
   revision_id second_rid = right_rid;
-  file_id my_fid(string("9012901290129012901290129012901290129012"));
+  file_id my_fid(decode_hexenc("9012901290129012901290129012901290129012"));
 
   testing_node_id_source nis;
 
============================================================
--- roster_delta.cc	1c7bb6d30b4a3701b962bab9e8956881f0a4fcea
+++ roster_delta.cc	88f180cd499cf6894014d8fee8a708592358b946
@@ -21,6 +21,7 @@
 #include "roster_delta.hh"
 #include "basic_io.hh"
 #include "paths.hh"
+#include "transforms.hh"
 
 using boost::lexical_cast;
 using std::pair;
@@ -411,7 +412,7 @@ namespace 
         std::string s;
         parser.hex(s);
         safe_insert(d.files_added,
-                    make_pair(loc, make_pair(nid, file_id(s))));
+                    make_pair(loc, make_pair(nid, file_id(decode_hexenc(s)))));
       }
     while (parser.symp(syms::delta))
       {
@@ -420,7 +421,7 @@ namespace 
         parser.esym(syms::content);
         std::string s;
         parser.hex(s);
-        safe_insert(d.deltas_applied, make_pair(nid, file_id(s)));
+        safe_insert(d.deltas_applied, make_pair(nid, file_id(decode_hexenc(s))));
       }
     while (parser.symp(syms::attr_cleared))
       {
============================================================
--- roster_merge.cc	d565f9299ca85d77bd1d7f2a29196d7161f0ea08
+++ roster_merge.cc	343c0bf5bbb143432954a86f0174a7a5bc76402e
@@ -1279,6 +1279,7 @@ roster_merge(roster_t const & left_paren
 #ifdef BUILD_UNIT_TESTS
 #include "unit_tests.hh"
 
+#include "transforms.hh"
 #include "roster_delta.hh"
 
 // cases for testing:
@@ -1379,7 +1380,7 @@ void string_to_set(string const & from, 
   for (string::const_iterator i = from.begin(); i != from.end(); ++i)
     {
       string rid_str(40, *i);
-      to.insert(revision_id(rid_str));
+      to.insert(revision_id(decode_hexenc(rid_str)));
     }
 }
 
@@ -1435,8 +1436,8 @@ test_a_scalar_merge_impl(scalar_val left
   scalar.check_result(left_val, right_val, result, expected_outcome);
 }
 
-static const revision_id root_rid = revision_id(string("0000000000000000000000000000000000000000"));
-static const file_id arbitrary_file = file_id(string("0000000000000000000000000000000000000000"));
+static const revision_id root_rid = revision_id(decode_hexenc("0000000000000000000000000000000000000000"));
+static const file_id arbitrary_file = file_id(decode_hexenc("0000000000000000000000000000000000000000"));
 
 struct base_scalar
 {
@@ -1664,9 +1665,9 @@ struct file_content_scalar : public virt
   file_id content_for(scalar_val val)
   {
     I(val != scalar_conflict);
-    return file_id(string((val == scalar_a)
-                               ? "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-                               : "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
+    return file_id(decode_hexenc((val == scalar_a)
+                    ? "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                    : "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
   }
 
   void
@@ -1698,7 +1699,7 @@ struct file_content_scalar : public virt
         I(null_id(content));
         // resolve the conflict, thus making sure that resolution works and
         // that this was the only conflict signaled
-        content = file_id(string("ffffffffffffffffffffffffffffffffffffffff"));
+        content = file_id(decode_hexenc("ffffffffffffffffffffffffffffffffffffffff"));
         result.file_content_conflicts.pop_back();
         break;
       }
@@ -1849,15 +1850,15 @@ namespace
 
 namespace
 {
-  const revision_id a_uncommon1 = revision_id(string("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
-  const revision_id a_uncommon2 = revision_id(string("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
-  const revision_id b_uncommon1 = revision_id(string("cccccccccccccccccccccccccccccccccccccccc"));
-  const revision_id b_uncommon2 = revision_id(string("dddddddddddddddddddddddddddddddddddddddd"));
-  const revision_id common1 = revision_id(string("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"));
-  const revision_id common2 = revision_id(string("ffffffffffffffffffffffffffffffffffffffff"));
+  const revision_id a_uncommon1 = revision_id(decode_hexenc("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
+  const revision_id a_uncommon2 = revision_id(decode_hexenc("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
+  const revision_id b_uncommon1 = revision_id(decode_hexenc("cccccccccccccccccccccccccccccccccccccccc"));
+  const revision_id b_uncommon2 = revision_id(decode_hexenc("dddddddddddddddddddddddddddddddddddddddd"));
+  const revision_id common1 = revision_id(decode_hexenc("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"));
+  const revision_id common2 = revision_id(decode_hexenc("ffffffffffffffffffffffffffffffffffffffff"));
 
-  const file_id fid1 = file_id(string("1111111111111111111111111111111111111111"));
-  const file_id fid2 = file_id(string("2222222222222222222222222222222222222222"));
+  const file_id fid1 = file_id(decode_hexenc("1111111111111111111111111111111111111111"));
+  const file_id fid2 = file_id(decode_hexenc("2222222222222222222222222222222222222222"));
 
 }