tree e695c8f41df0f8bbad5a14c285f8efd6c7f9ccd0
parent 33bc1b53d7294bcc17009e686f0c8644515cc625
author David Tolnay <dtolnay@gmail.com> 1510563345 -0800
committer David Tolnay <dtolnay@gmail.com> 1510563345 -0800
gpgsig -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABAgAGBQJaCV4RAAoJEPm6FDuV/22ClsQP+wagKuPGTa/4YLtR/4dwzTHY
 Qd/5FQWH1/KGSI3809MOXC3cBaTg7yrJe1YRJNsqXLJBGQfjG2yJTfqIMcdAfSTM
 lLWk+21HsUSxOvRCMSnFeIHWlV7J4Wn+WVKO6nLD0MqjC2DEslGup9ukWajF4Dmu
 yf8/pzx8g+Jneb6eAEOQbQ+Eaq81kCrJf1gPyHcrCEihBg7llYbudIr2ya+B3jo7
 4mmwNK7k4UiuX2RkP5uhykaS05n2v6MRz+OgBCfcFmyhhMHQuElXOp0ZZAxLEQWj
 zlYjyhNOKRZFvAEtUBOw5ANxcGE7jLt98xzR4/xt7bvsdJ3o//OHf5IlUUOn9o6g
 zHRqRDWq8QVKDmRU/hiWpxzUWnOFHCH8zg7RRA0ZyMk/qclZuUwmv8KsZYFAT1KR
 CRrFKoNjwMKVpM2upHOEoBXndTC9CPnwc9sJYvmqtkFMuh9o0dupTMmBlku/e3cL
 rkQqmAMIqKvF7mCJWGxXdqPr3blFMfM5UGwAwfkIkOlPwcn6+ogKNUKbetB4tcwS
 FJyl605cUMGNqXvWSsUAU3S9y6qqhp7mVL3Zg+clKjWx7jftsh0IzfXW+eBq2f/U
 dbCBAMhw8kxff1QNm84aV52DMXVHEVdFu2s8Emyl2rWe5aKFCmiLmwbRevRAeIzK
 6bqgkwkdWq6uf82NOiOl
 =YE1C
 -----END PGP SIGNATURE-----

Rename Rptr -> Reference
