#
#
# patch "constants.hh"
#  from [35e5834105b0ab3572749d071313fbd106b81fe0]
#    to [1eff8ec9e2bbfd15464429ff5a88ffc475579328]
# 
# patch "crypto_tests.cc"
#  from [ae19397a3156f4b436d2c4d1ceb3e1a2572bf2b6]
#    to [ce74687f7d5c51fae17f2351b66648af05b88c42]
# 
# patch "restrictions.cc"
#  from [397f2e25c4394dac398e38cd82c0b61359e0d11b]
#    to [2a808b3096b301cafd357eefbdec5ecae8033678]
# 
# patch "roster.cc"
#  from [41d3fb22062eb92c165e9e61973864a776825784]
#    to [883eb12d62c7fbe359cf2ade5d1cc2f759087e23]
# 
# patch "roster_merge.cc"
#  from [4e571728df3aed7038f7440aa0f5e1d8b363fcaa]
#    to [836d3898aa85477d1e5b9147222ac0697d6f477a]
#
============================================================
--- constants.hh	35e5834105b0ab3572749d071313fbd106b81fe0
+++ constants.hh	1eff8ec9e2bbfd15464429ff5a88ffc475579328
@@ -29,11 +29,14 @@ namespace constants
   // number of characters in a SHA1 id
   std::size_t const idlen = 40;
 
+  // number of binary bytes, ditto
+  std::size_t const idlen_bytes = idlen / 2;
+
   // number of characters in an encoded epoch
   std::size_t const epochlen = idlen;
 
   // number of characters in a raw epoch
-  std::size_t const epochlen_bytes = epochlen / 2;
+  std::size_t const epochlen_bytes = idlen_bytes;
 
   // number of seconds in window, in which to consider CVS commits equivalent
   // if they have otherwise compatible contents (author, changelog)
============================================================
--- crypto_tests.cc	ae19397a3156f4b436d2c4d1ceb3e1a2572bf2b6
+++ crypto_tests.cc	ce74687f7d5c51fae17f2351b66648af05b88c42
@@ -1057,7 +1057,7 @@ UNIT_TEST(crypto, calculate_ident)
   hexenc<id> houtput2;
 
   //SHA Short Message Test
-  data input(decode_hexenc("5e"));
+  data input("\x5e");
   string ident("5e6f80a34a9798cafc6a5db96cc57ba4c4db59c2");
 
   calculate_ident(input, output);
============================================================
--- restrictions.cc	397f2e25c4394dac398e38cd82c0b61359e0d11b
+++ restrictions.cc	2a808b3096b301cafd357eefbdec5ecae8033678
@@ -17,7 +17,7 @@
 
 #ifdef BUILD_UNIT_TESTS
 # include "unit_tests.hh"
-# include "transforms.hh"
+# include "constants.hh"
 #else
 # include "work.hh"
 #endif
@@ -489,46 +489,49 @@ using std::string;
 #define fp_yyf file_path_internal("y/y/f")
 #define fp_yyg file_path_internal("y/y/g")
 
-node_id nid_root;
-node_id nid_f;
-node_id nid_g;
+namespace
+{
+  node_id nid_root;
+  node_id nid_f;
+  node_id nid_g;
 
-node_id nid_x;
-node_id nid_xf;
-node_id nid_xg;
-node_id nid_xx;
-node_id nid_xxf;
-node_id nid_xxg;
-node_id nid_xy;
-node_id nid_xyf;
-node_id nid_xyg;
+  node_id nid_x;
+  node_id nid_xf;
+  node_id nid_xg;
+  node_id nid_xx;
+  node_id nid_xxf;
+  node_id nid_xxg;
+  node_id nid_xy;
+  node_id nid_xyf;
+  node_id nid_xyg;
 
-node_id nid_y;
-node_id nid_yf;
-node_id nid_yg;
-node_id nid_yx;
-node_id nid_yxf;
-node_id nid_yxg;
-node_id nid_yy;
-node_id nid_yyf;
-node_id nid_yyg;
+  node_id nid_y;
+  node_id nid_yf;
+  node_id nid_yg;
+  node_id nid_yx;
+  node_id nid_yxf;
+  node_id nid_yxg;
+  node_id nid_yy;
+  node_id nid_yyf;
+  node_id nid_yyg;
 
-file_id fid_f(decode_hexenc("1000000000000000000000000000000000000000"));
-file_id fid_g(decode_hexenc("2000000000000000000000000000000000000000"));
+  file_id fid_f  (string(constants::idlen_bytes, '\x11'));
+  file_id fid_g  (string(constants::idlen_bytes, '\x22'));
 
-file_id fid_xf(decode_hexenc("3000000000000000000000000000000000000000"));
-file_id fid_xg(decode_hexenc("4000000000000000000000000000000000000000"));
-file_id fid_xxf(decode_hexenc("5000000000000000000000000000000000000000"));
-file_id fid_xxg(decode_hexenc("6000000000000000000000000000000000000000"));
-file_id fid_xyf(decode_hexenc("7000000000000000000000000000000000000000"));
-file_id fid_xyg(decode_hexenc("8000000000000000000000000000000000000000"));
+  file_id fid_xf (string(constants::idlen_bytes, '\x33'));
+  file_id fid_xg (string(constants::idlen_bytes, '\x44'));
+  file_id fid_xxf(string(constants::idlen_bytes, '\x55'));
+  file_id fid_xxg(string(constants::idlen_bytes, '\x66'));
+  file_id fid_xyf(string(constants::idlen_bytes, '\x77'));
+  file_id fid_xyg(string(constants::idlen_bytes, '\x88'));
 
-file_id fid_yf(decode_hexenc("9000000000000000000000000000000000000000"));
-file_id fid_yg(decode_hexenc("a000000000000000000000000000000000000000"));
-file_id fid_yxf(decode_hexenc("b000000000000000000000000000000000000000"));
-file_id fid_yxg(decode_hexenc("c000000000000000000000000000000000000000"));
-file_id fid_yyf(decode_hexenc("d000000000000000000000000000000000000000"));
-file_id fid_yyg(decode_hexenc("e000000000000000000000000000000000000000"));
+  file_id fid_yf (string(constants::idlen_bytes, '\x99'));
+  file_id fid_yg (string(constants::idlen_bytes, '\xaa'));
+  file_id fid_yxf(string(constants::idlen_bytes, '\xbb'));
+  file_id fid_yxg(string(constants::idlen_bytes, '\xcc'));
+  file_id fid_yyf(string(constants::idlen_bytes, '\xdd'));
+  file_id fid_yyg(string(constants::idlen_bytes, '\xee'));
+}
 
 static void setup(roster_t & roster)
 {
============================================================
--- roster.cc	41d3fb22062eb92c165e9e61973864a776825784
+++ roster.cc	883eb12d62c7fbe359cf2ade5d1cc2f759087e23
@@ -266,7 +266,7 @@ dump(node_t const & n, string & out)
   oss << "type: ";
   if (is_file_t(n))
     {
-      string fcontent = decode_hexenc(
+      string fcontent = encode_hexenc(
         downcast_to_file_t(n)->content.inner()());
       oss << "file\n"
           << "content: " << fcontent << '\n';
@@ -3500,10 +3500,10 @@ namespace
     return s;
   }
 
-  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"));
+  revision_id old_rid(string(constants::idlen_bytes, '\x00'));
+  revision_id left_rid(string(constants::idlen_bytes, '\x11'));
+  revision_id right_rid(string(constants::idlen_bytes, '\x22'));
+  revision_id new_rid(string(constants::idlen_bytes, '\x44'));
 
 ////////////////
 // These classes encapsulate information about all the different scalars
@@ -3577,7 +3577,7 @@ namespace
                          roster_t & roster, marking_map & markings)
     {
       make_file(scalar_origin_rid, nid,
-                file_id(decode_hexenc("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")),
+                file_id(string(constants::idlen_bytes, '\xaa')),
                 roster, markings);
     }
     static void make_file(revision_id const & scalar_origin_rid, node_id nid,
@@ -3615,13 +3615,13 @@ namespace
     {
       safe_insert(values,
                   make_pair(scalar_a,
-                            file_id(decode_hexenc("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))));
+                            file_id(string(constants::idlen_bytes, '\xaa'))));
       safe_insert(values,
                   make_pair(scalar_b,
-                            file_id(decode_hexenc("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))));
+                            file_id(string(constants::idlen_bytes, '\xbb'))));
       safe_insert(values,
                   make_pair(scalar_c,
-                            file_id(decode_hexenc("cccccccccccccccccccccccccccccccccccccccc"))));
+                            file_id(string(constants::idlen_bytes, '\xcc'))));
     }
     virtual void
     set(revision_id const & scalar_origin_rid, scalar_val val,
@@ -4495,8 +4495,8 @@ UNIT_TEST(roster, write_roster)
   file_path fo = file_path_internal("fo");
   file_path xx = file_path_internal("xx");
 
-  file_id f1(decode_hexenc("1111111111111111111111111111111111111111"));
-  revision_id rid(decode_hexenc("1234123412341234123412341234123412341234"));
+  file_id f1(string(constants::idlen_bytes, '\x11'));
+  revision_id rid(string(constants::idlen_bytes, '\x44'));
   node_id nid;
 
   // if adding new nodes, add them at the end to keep the node_id order
@@ -4583,46 +4583,46 @@ UNIT_TEST(roster, write_roster)
                       "\n"
                       "      dir \"\"\n"
                       "    ident \"1\"\n"
-                      "    birth [1234123412341234123412341234123412341234]\n"
-                      "path_mark [1234123412341234123412341234123412341234]\n"
+                      "    birth [4444444444444444444444444444444444444444]\n"
+                      "path_mark [4444444444444444444444444444444444444444]\n"
                       "\n"
                       "      dir \"fo\"\n"
                       "    ident \"4\"\n"
-                      "    birth [1234123412341234123412341234123412341234]\n"
-                      "path_mark [1234123412341234123412341234123412341234]\n"
+                      "    birth [4444444444444444444444444444444444444444]\n"
+                      "path_mark [4444444444444444444444444444444444444444]\n"
                       "\n"
                       "      dir \"foo\"\n"
                       "    ident \"2\"\n"
-                      "    birth [1234123412341234123412341234123412341234]\n"
-                      "path_mark [1234123412341234123412341234123412341234]\n"
+                      "    birth [4444444444444444444444444444444444444444]\n"
+                      "path_mark [4444444444444444444444444444444444444444]\n"
                       "\n"
                       "      dir \"foo/ang\"\n"
                       "    ident \"6\"\n"
-                      "    birth [1234123412341234123412341234123412341234]\n"
-                      "path_mark [1234123412341234123412341234123412341234]\n"
+                      "    birth [4444444444444444444444444444444444444444]\n"
+                      "path_mark [4444444444444444444444444444444444444444]\n"
                       "\n"
                       "        file \"foo/bar\"\n"
                       "     content [1111111111111111111111111111111111111111]\n"
                       "       ident \"5\"\n"
                       "        attr \"fascist\" \"tidiness\"\n"
-                      "       birth [1234123412341234123412341234123412341234]\n"
-                      "   path_mark [1234123412341234123412341234123412341234]\n"
-                      "content_mark [1234123412341234123412341234123412341234]\n"
-                      "   attr_mark \"fascist\" [1234123412341234123412341234123412341234]\n"
+                      "       birth [4444444444444444444444444444444444444444]\n"
+                      "   path_mark [4444444444444444444444444444444444444444]\n"
+                      "content_mark [4444444444444444444444444444444444444444]\n"
+                      "   attr_mark \"fascist\" [4444444444444444444444444444444444444444]\n"
                       "\n"
                       "         dir \"foo/zoo\"\n"
                       "       ident \"7\"\n"
                       "dormant_attr \"regime\"\n"
-                      "       birth [1234123412341234123412341234123412341234]\n"
-                      "   path_mark [1234123412341234123412341234123412341234]\n"
-                      "   attr_mark \"regime\" [1234123412341234123412341234123412341234]\n"
+                      "       birth [4444444444444444444444444444444444444444]\n"
+                      "   path_mark [4444444444444444444444444444444444444444]\n"
+                      "   attr_mark \"regime\" [4444444444444444444444444444444444444444]\n"
                       "\n"
                       "      dir \"xx\"\n"
                       "    ident \"3\"\n"
                       "     attr \"say\" \"hello\"\n"
-                      "    birth [1234123412341234123412341234123412341234]\n"
-                      "path_mark [1234123412341234123412341234123412341234]\n"
-                      "attr_mark \"say\" [1234123412341234123412341234123412341234]\n"
+                      "    birth [4444444444444444444444444444444444444444]\n"
+                      "path_mark [4444444444444444444444444444444444444444]\n"
+                      "attr_mark \"say\" [4444444444444444444444444444444444444444]\n"
                       ));
     MM(expected);
 
============================================================
--- roster_merge.cc	4e571728df3aed7038f7440aa0f5e1d8b363fcaa
+++ roster_merge.cc	836d3898aa85477d1e5b9147222ac0697d6f477a
@@ -1281,8 +1281,7 @@ roster_merge(roster_t const & left_paren
 
 #ifdef BUILD_UNIT_TESTS
 #include "unit_tests.hh"
-
-#include "transforms.hh"
+#include "constants.hh"
 #include "roster_delta.hh"
 
 // cases for testing:
@@ -1382,8 +1381,8 @@ void string_to_set(string const & from, 
   to.clear();
   for (string::const_iterator i = from.begin(); i != from.end(); ++i)
     {
-      string rid_str(40, *i);
-      to.insert(revision_id(decode_hexenc(rid_str)));
+      char label = (*i - '0') << 4 + (*i - '0');
+      to.insert(revision_id(string(constants::idlen_bytes, label)));
     }
 }
 
@@ -1439,8 +1438,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(decode_hexenc("0000000000000000000000000000000000000000"));
-static const file_id arbitrary_file = file_id(decode_hexenc("0000000000000000000000000000000000000000"));
+static const revision_id root_rid(string(constants::idlen_bytes, '\0'));
+static const file_id arbitrary_file(string(constants::idlen_bytes, '\0'));
 
 struct base_scalar
 {
@@ -1668,9 +1667,8 @@ struct file_content_scalar : public virt
   file_id content_for(scalar_val val)
   {
     I(val != scalar_conflict);
-    return file_id(decode_hexenc((val == scalar_a)
-                    ? "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-                    : "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"));
+    return file_id(string(constants::idlen_bytes,
+                          (val == scalar_a) ? '\xaa' : '\xbb'));
   }
 
   void
@@ -1702,7 +1700,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(decode_hexenc("ffffffffffffffffffffffffffffffffffffffff"));
+        content = file_id(string(constants::idlen_bytes, '\xff'));
         result.file_content_conflicts.pop_back();
         break;
       }
@@ -1853,16 +1851,15 @@ namespace
 
 namespace
 {
-  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 revision_id a_uncommon1(string(constants::idlen_bytes, '\xaa'));
+  const revision_id a_uncommon2(string(constants::idlen_bytes, '\xbb'));
+  const revision_id b_uncommon1(string(constants::idlen_bytes, '\xcc'));
+  const revision_id b_uncommon2(string(constants::idlen_bytes, '\xdd'));
+  const revision_id common1(string(constants::idlen_bytes, '\xee'));
+  const revision_id common2(string(constants::idlen_bytes, '\xff'));
 
-  const file_id fid1 = file_id(decode_hexenc("1111111111111111111111111111111111111111"));
-  const file_id fid2 = file_id(decode_hexenc("2222222222222222222222222222222222222222"));
-
+  const file_id fid1(string(constants::idlen_bytes, '\x11'));
+  const file_id fid2(string(constants::idlen_bytes, '\x22'));
 }
 
 static void