upstream/mercurial-mirror Commit - r42406:e64d8d73

merge with stable

Augie Fackler -

r42406:e64d8d73 default

parent child

.hgsigs

0 +1 0

 fb62a3a673d5322f6274a44ba6456e5e4b3b37 0 iD8DBQBEYmO2ywK+sNU5EO8RAnaYAKCO7x15xUn5mnhqWNXqk/ehlhRt2QCfRDfY0LrUq2q4oK/KypuJYPHgq1A=
 be3001847cb18a23c403439d9e7d0ace30804e9 0 iD8DBQBExUbjywK+sNU5EO8RAhzxAKCtyHAQUzcTSZTqlfJ0by6vhREwWQCghaQFHfkfN0l9/40EowNhuMOKnJk=
 a957364b1b89c150f2d0e60a99befe0ee08bd3 0 iD8DBQBFfL2QywK+sNU5EO8RAjYFAKCoGlaWRTeMsjdmxAjUYx6diZxOBwCfY6IpBYsKvPTwB3oktnPt5Rmrlys=
 c29bfec36d5540fbe1c976810aefecfd1d2 0 iD8DBQBFheweywK+sNU5EO8RAt7VAKCrqJQWT2/uo2RWf0ZI4bLp6v82jACgjrMdsaTbxRsypcmEsdPhlG6/8F4=
              fb4b6d5fe100b0886f8bc3d6731ec0e5ed5c4694 0 iD8DBQBGgHicywK+sNU5EO8RAgNxAJ0VG8ixAaeudx4sZbhngI1syu49HQCeNUJQfWBgA8bkJ2pvsFpNxwYaX3I=
              23889160905a1b09fffe1c07378e9fc1827606eb 0 iD8DBQBHGTzoywK+sNU5EO8RAr/UAJ0Y8s4jQtzgS+G9vM8z6CWBThZ8fwCcCT5XDj2XwxKkz/0s6UELwjsO3LU=
              bae2e9c838e90a393bae3973a7850280413e091a 0 iD8DBQBH6DO5ywK+sNU5EO8RAsfrAJ0e4r9c9GF/MJsM7Xjd3NesLRC3+ACffj6+6HXdZf8cswAoFPO+DY00oD0=
              d5cbbe2c49cee22a9fbeb9ea41daa0ac4e26b846 0 iD8DBQBINdwsywK+sNU5EO8RAjIUAKCPmlFJSpsPAAUKF+iNHAwVnwmzeQCdEXrL27CWclXuUKdbQC8De7LICtE=
              d2375bbee6d47e62ba8e415c86e83a465dc4dce9 0 iD8DBQBIo1wpywK+sNU5EO8RAmRNAJ94x3OFt6blbqu/yBoypm/AJ44fuACfUaldXcV5z9tht97hSp22DVTEPGc=
 a67430f92f15ea5159c26b09ec4839a0c549a26 0 iEYEABECAAYFAkk1hykACgkQywK+sNU5EO85QACeNJNUanjc2tl4wUoPHNuv+lSj0ZMAoIm93wSTc/feyYnO2YCaQ1iyd9Nu
 e510d433969e277b1863c317b674cbee2065 0 iEYEABECAAYFAklNbbAACgkQywK+sNU5EO8o+gCfeb2/lfIJZMvyDA1m+G1CsBAxfFsAoIa6iAMG8SBY7hW1Q85Yf/LXEvaE
 a4eb81fb4f4742451591489e2797dc47903277 0 iEYEABECAAYFAklcAnsACgkQywK+sNU5EO+uXwCbBVHNNsLy1g7BlAyQJwadYVyHOXoAoKvtAVO71+bv7EbVoukwTzT+P4Sx
 efa41037e280d08cfb07c09ad485df30fb0ea8 0 iEYEABECAAYFAkmvJRQACgkQywK+sNU5EO9XZwCeLMgDgPSMWMm6vgjL4lDs2pEc5+0AnRxfiFbpbBfuEFTqKz9nbzeyoBlx
              02981000012e3adf40c4849bd7b3d5618f9ce82d 0 iEYEABECAAYFAknEH3wACgkQywK+sNU5EO+uXwCeI+LbLMmhjU1lKSfU3UWJHjjUC7oAoIZLvYDGOL/tNZFUuatc3RnZ2eje
 d40e7c885fa6e95f89134809b3ec7bdbca34b 0 iEYEABECAAYFAkpL2X4ACgkQywK+sNU5EO9FOwCfXJycjyKJXsvQqKkHrglwOQhEKS4An36GfKzptfN8b1qNc3+ya/5c2WOM
 ef6c14a1e8e83a31226f5881b7fe6095bbfa6f6 0 iEYEABECAAYFAkpopLIACgkQywK+sNU5EO8QSgCfZ0ztsd071rOa2lhmp9Fyue/WoI0AoLTei80/xrhRlB8L/rZEf2KBl8dA
 ec469f9b556f11819937cf68ee53f2be927ebf 0 iEYEABECAAYFAksBuxAACgkQywK+sNU5EO+mBwCfagB+A0txzWZ6dRpug3LEoK7Z1QsAoKpbk8vsLjv6/oRDicSk/qBu33+m
 d7ea6fe3aa4ab9ec274a68846779153789de9 0 iEYEABECAAYFAksVw0kACgkQywK+sNU5EO/oZwCfdfBEkgp38xq6wN2F4nj+SzofrJIAnjmxt04vaJSeOOeHylHvk6lzuQsw
 a0b14a68621f6990c54fdba0083f6f20935bf 0 iEYEABECAAYFAks+jCoACgkQywK+sNU5EO9J8wCeMUGF9E/gS2UBsqIz56WS4HMPRPUAoI5J95mwEIK8Clrl7qFRidNI6APq
 aa619c4c2c09907034d9824ebb1dd0e878206eb 0 iEYEABECAAYFAktm9IsACgkQywK+sNU5EO9XGgCgk4HclRQhexEtooPE5GcUCdB6M8EAn2ptOhMVbIoO+JncA+tNACPFXh0O
              ff2704a8ded37fbebd8b6eb5ec733731d725da8a 0 iEYEABECAAYFAkuRoSQACgkQywK+sNU5EO//3QCeJDc5r2uFyFCtAlpSA27DEE5rrxAAn2FSwTy9fhrB3QAdDQlwkEZcQzDh
 b01dab594167bc0dd33331dbaa6dca3dca1b3aa 0 iEYEABECAAYFAku1IwIACgkQywK+sNU5EO9MjgCdHLVwkTZlNHxhcznZKBL1rjN+J7cAoLLWi9LTL6f/TgBaPSKOy1ublbaW
 f725929f0c48c5fb3b90c071fc3066012456ca 0 iEYEABECAAYFAkvclvsACgkQywK+sNU5EO9FSwCeL9i5x8ALW/LE5+lCX6MFEAe4MhwAn1ev5o6SX6GrNdDfKweiemfO2VBk
              fdcf80f26604f233dc4d8f0a5ef9d7470e317e8a 0 iEYEABECAAYFAkvsKTkACgkQywK+sNU5EO9qEACgiSiRGvTG2vXGJ65tUSOIYihTuFAAnRzRIqEVSw8M8/RGeUXRps0IzaCO
 fe2629c6fd0c74c90bd066e77387c2b02e8437 0 iEYEABECAAYFAkwFLRsACgkQywK+sNU5EO+pJACgp13tPI+pbwKZV+LeMjcQ4H6tCZYAoJebzhd6a8yYx6qiwpJxA9BXZNXy
              f786fc4b8764cd2a5526d259cf2f94d8a66924d9 0 iEYEABECAAYFAkwsyxcACgkQywK+sNU5EO+crACfUpNAF57PmClkSri9nJcBjb2goN4AniPCNaKvnki7TnUsi1u2oxltpKKL
              bf1774d95bde614af3956d92b20e2a0c68c5fec7 0 iEYEABECAAYFAkxVwccACgkQywK+sNU5EO+oFQCeJzwZ+we1fIIyBGCddHceOUAN++cAnjvT6A8ZWW0zV21NXIFF1qQmjxJd
              c00f03a4982e467fb6b6bd45908767db6df4771d 0 iEYEABECAAYFAkxXDqsACgkQywK+sNU5EO/GJACfT9Rz4hZOxPQEs91JwtmfjevO84gAmwSmtfo5mmWSm8gtTUebCcdTv0Kf
              ff5cec76b1c5b6be9c3bb923aae8c3c6d079d6b9 0 iD8DBQBMdo+qywK+sNU5EO8RAqQpAJ975BL2CCAiWMz9SXthNQ9xG181IwCgp4O+KViHPkufZVFn2aTKMNvcr1A=
 d8bff78c96fe7e33237b257558ee97290048a4 0 iD8DBQBMpfvdywK+sNU5EO8RAsxVAJ0UaL1XB51C76JUBhafc9GBefuMxwCdEWkTOzwvE0SarJBe9i008jhbqW4=
 b9e0f96c7bc788e5667c146a58a9440a55 0 iD8DBQBMz0HOywK+sNU5EO8RAlsEAJ0USh6yOG7OrWkADGunVt9QimBQnwCbBqeMnKgSbwEw8jZwE3Iz1mdrYlo=
              4438875ec01bd0fc32be92b0872eb6daeed4d44f 0 iD8DBQBM4WYUywK+sNU5EO8RAhCVAJ0dJswachwFAHALmk1x0RJehxzqPQCbBNskP9n/X689jB+btNTZTyKU/fw=
 aff4f144ad356311318b0011df0bb21f2c97429 0 iD8DBQBM9uxXywK+sNU5EO8RAv+4AKCDj4qKP16GdPaq1tP6BUwpM/M1OACfRyzLPp/qiiN8xJTWoWYSe/XjJug=
              e3bf16703e2601de99e563cdb3a5d50b64e6d320 0 iD8DBQBNH8WqywK+sNU5EO8RAiQTAJ9sBO+TeiGro4si77VVaQaA6jcRUgCfSA28dBbjj0oFoQwvPoZjANiZBH8=
              a6c855c32ea081da3c3b8ff628f1847ff271482f 0 iD8DBQBNSJJ+ywK+sNU5EO8RAoJaAKCweDEF70fu+r1Zn7pYDXdlk5RuSgCeO9gK/eit8Lin/1n3pO7aYguFLok=
 b2155623ee2559caf288fd333f30475966c4525 0 iD8DBQBNSJeBywK+sNU5EO8RAm1KAJ4hW9Cm9nHaaGJguchBaPLlAr+O3wCgqgmMok8bdAS06N6PL60PSTM//Gg=
              2616325766e3504c8ae7c84bd15ee610901fe91d 0 iD8DBQBNbWy9ywK+sNU5EO8RAlWCAJ4mW8HbzjJj9GpK98muX7k+7EvEHwCfaTLbC/DH3QEsZBhEP+M8tzL6RU4=
              aa1f3be38ab127280761889d2dca906ca465b5f4 0 iD8DBQBNeQq7ywK+sNU5EO8RAlEOAJ4tlEDdetE9lKfjGgjbkcR8PrC3egCfXCfF3qNVvU/2YYjpgvRwevjvDy0=
              b032bec2c0a651ca0ddecb65714bfe6770f67d70 0 iD8DBQBNlg5kywK+sNU5EO8RAnGEAJ9gmEx6MfaR4XcG2m/93vwtfyzs3gCgltzx8/YdHPwqDwRX/WbpYgi33is=
 cb1e95676ad089596bd81d0937cad37d6e3b7fb 0 iD8DBQBNvTy4ywK+sNU5EO8RAmp8AJ9QnxK4jTJ7G722MyeBxf0UXEdGwACgtlM7BKtNQfbEH/fOW5y+45W88VI=
 af5d9f6b22387913e1d11350fb8cb7c1487dd 0 iD8DBQBN5q/8ywK+sNU5EO8RArRGAKCNGT94GKIYtSuwZ57z1sQbcw6uLACfffpbMV4NAPMl8womAwg+7ZPKnIU=
              de9eb6b1da4fc522b1cab16d86ca166204c24f25 0 iD8DBQBODhfhywK+sNU5EO8RAr2+AJ4ugbAj8ae8/K0bYZzx3sascIAg1QCeK3b+zbbVVqd3b7CDpwFnaX8kTd4=
 a43e23b8c55b4566b8200bf69fe2158485a2634 0 iD8DBQBONzIMywK+sNU5EO8RAj5SAJ0aPS3+JHnyI6bHB2Fl0LImbDmagwCdGbDLp1S7TFobxXudOH49bX45Iik=
              d629f1e89021103f1753addcef6b310e4435b184 0 iD8DBQBOWAsBywK+sNU5EO8RAht4AJwJl9oNFopuGkj5m8aKuf7bqPkoAQCeNrEm7UhFsZKYT5iUOjnMV7s2LaM=
 a9292e430e35766c552066ed3e87c557b803b 0 iD8DBQBOh3zUywK+sNU5EO8RApFMAKCD3Y/u3avDFndznwqfG5UeTHMlvACfUivPIVQZyDZnhZMq0UhC6zhCEQg=
              384082750f2c51dc917d85a7145748330fa6ef4d 0 iD8DBQBOmd+OywK+sNU5EO8RAgDgAJ9V/X+G7VLwhTpHrZNiOHabzSyzYQCdE2kKfIevJUYB9QLAWCWP6DPwrwI=
 d55b481ddfcc1dacb445179649e24ca861d 0 iD8DBQBOsFhpywK+sNU5EO8RAqM6AKCyfxUae3/zLuiLdQz+JR78690eMACfQ6JTBQib4AbE+rUDdkeFYg9K/+4=
 dbd1cef0c2f9f8bcf4ea303238105f716bda3 0 iD8DBQBO1/fWywK+sNU5EO8RAmoPAKCR5lpv1D6JLURHD8KVLSV4GRVEBgCgnd0Sy78ligNfqAMafmACRDvj7vo=
              6344043924497cd06d781d9014c66802285072e4 0 iD8DBQBPALgmywK+sNU5EO8RAlfhAJ9nYOdWnhfVDHYtDTJAyJtXBAQS9wCgnefoSQt7QABkbGxM+Q85UYEBuD0=
              db33555eafeaf9df1e18950e29439eaa706d399b 0 iD8DBQBPGdzxywK+sNU5EO8RAppkAJ9jOXhUVE/97CPgiMA0pMGiIYnesQCfengAszcBiSiKGugiI8Okc9ghU+Y=
 aa5b51f310fb3befd26bed99c02267f5c12c734 0 iD8DBQBPKZ9bywK+sNU5EO8RAt1TAJ45r1eJ0YqSkInzrrayg4TVCh0SnQCgm0GA/Ua74jnnDwVQ60lAwROuz1Q=
 e2cd303ecf8ca7c7eeebd785c34e5ed6b0f4a4 0 iD8DBQBPT/fvywK+sNU5EO8RAnfYAKCn7d0vwqIb100YfWm1F7nFD5B+FACeM02YHpQLSNsztrBCObtqcnfod7Q=
              b9bd95e61b49c221c4cca24e6da7c946fc02f992 0 iD8DBQBPeLsIywK+sNU5EO8RAvpNAKCtKe2gitz8dYn52IRF0hFOPCR7AQCfRJL/RWCFweu2T1vH/mUOCf8SXXc=
              d9e2f09d5488c395ae9ddbb320ceacd24757e055 0 iD8DBQBPju/dywK+sNU5EO8RArBYAJ9xtifdbk+hCOJO8OZa4JfHX8OYZQCeKPMBaBWiT8N/WHoOm1XU0q+iono=
 b3d087909e3c3ae44761efecdde8f319ef3 0 iD8DBQBPoFhIywK+sNU5EO8RAhzhAKCBj1n2jxPTkZNJJ5pSp3soa+XHIgCgsZZpAQxOpXwCp0eCdNGe0+pmxmg=
 de86462c5a9f42a3ad0f5e90ce5b1d221d25 0 iD8DBQBPovNWywK+sNU5EO8RAhgiAJ980T91FdPTRMmVONDhpkMsZwVIMACgg3bKvoWSeuCW28llUhAJtUjrMv0=
 a358df5bbbe404ca25730c9c459b34263441dc 0 iD8DBQBPyZsWywK+sNU5EO8RAnpLAJ48qrGDJRT+pteS0mSQ11haqHstPwCdG4ccGbk+0JHb7aNy8/NRGAOqn9w=
              b013baa3898e117959984fc64c29d8c784d2f28b 0 iD8DBQBP8QOPywK+sNU5EO8RAqimAKCFRSx0lvG6y8vne2IhNG062Hn0dACeMLI5/zhpWpHBIVeAAquYfx2XFeA=
 f5094bb3f423fc799e471aac2aee81a7ce57a0b 0 iD8DBQBQGiL8ywK+sNU5EO8RAq5oAJ4rMMCPx6O+OuzNXVOexogedWz/QgCeIiIxLd76I4pXO48tdXhr0hQcBuM=
 ae4ddb654eb2d5fd35bff358c738414432 0 iD8DBQBQQkq0ywK+sNU5EO8RArDTAJ9nk5CySnNAjAXYvqvx4uWCw9ThZwCgqmFRehH/l+oTwj3f8nw8u8qTCdc=
              b3f0f9a39c4e1d0250048cd803ab03542d6f140a 0 iD8DBQBQamltywK+sNU5EO8RAlsqAJ4qF/m6aFu4mJCOKTiAP5RvZFK02ACfawYShUZO6OXEFfveU0aAxDR0M1k=
              d118a4f4fd16d9b558ec3f3e87bfee772861d2b7 0 iD8DBQBQgPV5ywK+sNU5EO8RArylAJ0abcx5NlDjyv3ZDWpAfRIHyRsJtQCgn4TMuEayqgxzrvadQZHdTEU2g38=
 ad823b5d58c68903a6153a25e3fb4ed25239d 0 iD8DBQBQkuT9ywK+sNU5EO8RAhB4AKCeerItoK2Jipm2cVf4euGofAa/WACeJj3TVd4pFILpb+ogj7ebweFLJi0=
 c10cf8191469e7c3c8844922e17e71a176cb7cb 0 iD8DBQBQvQWoywK+sNU5EO8RAnq3AJoCn98u4geFx5YaQaeh99gFhCd7bQCgjoBwBSUyOvGd0yBy60E3Vv3VZhM=
              a4765077b65e6ae29ba42bab7834717b5072d5ba 0 iD8DBQBQ486sywK+sNU5EO8RAhmJAJ90aLfLKZhmcZN7kqphigQJxiFOQACeJ5IUZxjGKH4xzi3MrgIcx9n+dB0=
              f5fbe15ca7449f2c9a3cf817c86d0ae68b307214 0 iD8DBQBQ+yuYywK+sNU5EO8RAm9JAJoD/UciWvpGeKBcpGtZJBFJVcL/HACghDXSgQ+xQDjB+6uGrdgAQsRR1Lg=
              a6088c05e43a8aee0472ca3a4f6f8d7dd914ebbf 0 iD8DBQBRDDROywK+sNU5EO8RAh75AJ9uJCGoCWnP0Lv/+XuYs4hvUl+sAgCcD36QgAnuw8IQXrvv684BAXAnHcA=
 d4df752e61fe7ae4f3682e0a0008573b0402 0 iD8DBQBRFYaoywK+sNU5EO8RAuErAJoDyhXn+lptU3+AevVdwAIeNFyR2gCdHzPHyWd+JDeWCUR+pSOBi8O2ppM=
 b7175377babacce80a6c1e12366d8032a6d4340 0 iD8DBQBRMCYgywK+sNU5EO8RAq1/AKCWKlt9ysibyQgYwoxxIOZv5J8rpwCcDSHQaaf1fFZUTnQsOePwcM2Y/Sg=
 c922c1b5145dab8baefefb0437d363b6a6c21c 0 iD8DBQBRWnUnywK+sNU5EO8RAuQRAJwM42cJqJPeqJ0jVNdMqKMDqr4dSACeP0cRVGz1gitMuV0x8f3mrZrqc7I=
 a7bd2dccd44ed571afe7424cd7f95594f27c092 0 iD8DBQBRXfBvywK+sNU5EO8RAn+LAKCsMmflbuXjYRxlzFwId5ptm8TZcwCdGkyLbZcASBOkzQUm/WW1qfknJHU=
 cd385856d98bacb2c3086f8897bc660c2beea 0 iD8DBQBRcM0BywK+sNU5EO8RAjp4AKCJBykQbvXhKuvLSMxKx3a2TBiXcACfbr/kLg5GlZTF/XDPmY+PyHgI/GM=
 f785b38af38d2fca6b8f3db56b8007a84cd73a 0 iD8DBQBRgZwNywK+sNU5EO8RAmO4AJ4u2ILGuimRP6MJgE2t65LZ5dAdkACgiENEstIdrlFC80p+sWKD81kKIYI=
              ddc7a6be20212d18f3e27d9d7e6f079a66d96f21 0 iD8DBQBRkswvywK+sNU5EO8RAiYYAJsHTHyHbJeAgmGvBTmDrfcKu4doUgCeLm7eGBjx7yAPUvEtxef8rAkQmXI=
              cceaf7af4c9e9e6fa2dbfdcfe9856c5da69c4ffd 0 iD8DBQBRqnFLywK+sNU5EO8RAsWNAJ9RR6t+y1DLFc2HeH0eN9VfZAKF9gCeJ8ezvhtKq/LMs0/nvcgKQc/d5jk=
 acc6e37a650f0fae37872e733382ac1c0c 0 iD8DBQBR0guxywK+sNU5EO8RArNkAKCq9pMihVzP8Os5kCmgbWpe5C37wgCgqzuPZTHvAsXF5wTyaSTMVa9Ccq4=
              f0d7721d7322dcfb5af33599c2543f27335334bb 0 iD8DBQBR8taaywK+sNU5EO8RAqeEAJ4idDhhDuEsgsUjeQgWNj498matHACfT67gSF5w0ylsrBx1Hb52HkGXDm0=
              f37b5a17e6a0ee17afde2cdde5393dd74715fb58 0 iD8DBQBR+ymFywK+sNU5EO8RAuSdAJkBMcd9DAZ3rWE9WGKPm2YZ8LBoXACfXn/wbEsVy7ZgJoUwiWmHSnQaWCI=
 a558f81dc73afeab4d7be63617392b130117f 0 iQIVAwUAUiZrIyBXgaxoKi1yAQK2iw//cquNqqSkc8Re5/TZT9I6NH+lh6DbOKjJP0Xl1Wqq0K+KSIUgZG4G32ovaEb2l5X0uY+3unRPiZ0ebl0YSw4Fb2ZiPIADXLBTOYRrY2Wwd3tpJeGI6wEgZt3SfcITV/g7NJrCjT3FlYoSOIayrExM80InSdcEM0Q3Rx6HKzY2acyxzgZeAtAW5ohFvHilSvY6p5Gcm4+QptMxvw45GPdreUmjeXZxNXNXZ8P+MjMz/QJbai/N7PjmK8lqnhkBsT48Ng/KhhmOkGntNJ2/ImBWLFGcWngSvJ7sfWwnyhndvGhe0Hq1NcCf7I8TjNDxU5TR+m+uW7xjXdLoDbUjBdX4sKXnh8ZjbYiODKBOrrDq25cf8nA/tnpKyE/qsVy60kOk6loY4XKiYmn1V49Ta0emmDx0hqo3HgxHHsHX0NDnGdWGol7cPRET0RzVobKq1A0jnrhPooWidvLh9bPzLonrWDo+ib+DuySoRkuYUK4pgZJ2mbg6daFOBEZygkSyRB8bo1UQUP7EgQDrWe4khb/5GHEfDkrQz3qu/sXvc0Ir1mOUWBFPHC2DjjCn/oMJuUkG1SwM8l2Bfv7h67ssES6YQ2+RjOix4yid7EXS/Ogl45PzCIPSI5+BbNs10JhE0w5uErBHlF53EDTe/TSLc+GU6DB6PP6dH912Njdr3jpNSUQ=
              e7fa36d2ad3a7944a52dca126458d6f482db3524 0 iQIVAwUAUktg4yBXgaxoKi1yAQLO0g//du/2ypYYUfmM/yZ4zztNKIvgMSGTDVbCCGB2y2/wk2EcolpjpGTkcgnJT413ksYtw78ZU+mvv0RjgrFCm8DQ8kroJaQZ2qHmtSUb42hPBPvtg6kL9YaA4yvp87uUBpFRavGS5uX4hhEIyvZKzhXUBvqtL3TfwR7ld21bj8j00wudqELyyU9IrojIY9jkJ3XL/4shBGgP7u6OK5g8yJ6zTnWgysUetxHBPrYjG25lziiiZQFvZqK1B3PUqAOaFPltQs0PB8ipOCAHQgJsjaREj8VmC3+rskmSSy66NHm6gAB9+E8oAgOcU7FzWbdYgnz4kR3M7TQvHX9U61NinPXC6Q9d1VPhO3E6sIGvqJ4YeQOn65V9ezYuIpFSlgQzCHMmLVnOV96Uv1R/Z39I4w7D3S5qoZcQT/siQwGbsZoPMGFYmqOK1da5TZWrrJWkYzc9xvzT9m3q3Wds5pmCmo4b/dIqDifWwYEcNAZ0/YLHwCN5SEZWuunkEwtU5o7TZAv3bvDDA6WxUrrHI/y9/qvvhXxsJnY8IueNhshdmWZfXKz+lJi2Dvk7DUlEQ1zZWSsozi1E+3biMPJO47jsxjoT/jmE5+GHLCgcnXXDVBeaVal99IOaTRFukiz2EMsry1s8fnwEE5XKDKRlU/dOPfsje0gc7bgE0QD/u3E4NJ99g9A=
 f2d8f2421314b1ddead8f7d0c91009358994 0 iQIVAwUAUmRq+yBXgaxoKi1yAQLolhAAi+l4ZFdQTu9yJDv22YmkmHH4fI3d5VBYgvfJPufpyaj7pX626QNW18UNcGSw2BBpYHIJzWPkk/4XznLVKr4Ciw2N3/yqloEFV0V2SSrTbMWiR9qXI4KJH+Df3KZnKs3FgiYpXkErL4GWkc1jLVR50xQ5RnkMljjtCd0NTeV2PHZ6gP2qbu6CS+5sm3AFhTDGnx8GicbMw76ZNw5M2G+T48yH9jn5KQi2SBThfi4H9Bpr8FDuR7PzQLgw9SbtYxtdQxNkK55k0nG4oLDxduNakU6SH9t8n8tdCfMt58kTzlQVrPFiTFjKu2n2JioDTz2HEivbZ5H757cu7SvpX8gW3paeBc57e+GOLMisMZABXLICq59c3QnrMwFY4FG+5cpiHVXoaZz/0bYCJx+IhU4QLWqZuzb18KSyHUCqQRzXlzS6QV5O7dY5YNQXFC44j/dS5zdgWMYo2mc6mVP2OaPUn7F6aQh5MCDYorPIOkcNjOg7ytajo7DXbzWt5Al8qt6386BJksyR3GAonc09+l8IFeNxk8HZNP4ETQ8aWj0dC9jgBDPK43T2Bju/i84s+U/bRe4tGSQalZUEv06mkIH/VRJp5w2izYTsdIjA4FT9d36OhaxlfoO1X6tHR9AyA3bF/g/ozvBwuo3kTRUUqo+Ggvx/DmcPQdDiZZQIqDBXch0=
              d825e4025e39d1c39db943cdc89818abd0a87c27 0 iQIVAwUAUnQlXiBXgaxoKi1yAQJd3BAAi7LjMSpXmdR7B8K98C3/By4YHsCOAocMl3JXiLd7SXwKmlta1zxtkgWwWJnNYE3lVJvGCl+l4YsGKmFu755MGXlyORh1x4ohckoC1a8cqnbNAgD6CSvjSaZfnINLGZQP1wIP4yWj0FftKVANQBjj/xkkxO530mjBYnUvyA4PeDd5A1AOUUu6qHzX6S5LcprEt7iktLI+Ae1dYTkiCpckDtyYUKIk3RK/4AGWwGCPddVWeV5bDxLs8GHyMbqdBwx+2EAMtyZfXT+z6MDRsL/gEBVOXHb/UR0qpYED+qFnbtTlxqQkRE/wBhwDoRzUgcSuukQ9iPn79WNDSdT5b6Jd393uEO5BNF/DB6rrOiWmlpoooWgTY9kcwGB02v0hhLrH5r1wkv8baaPl+qjCjBxf4CNKm/83KN5/umGbZlORqPSN5JVxK6vDNwFFmHLaZbMT1g27GsGOWm84VH+dgolgk4nmRNSO37eTNM5Y1C3Zf2amiqDSRcAxCgseg0Jh10G7i52SSTcZPI2MqrwT9eIyg8PTIxT1D5bPcCzkg5nTTL6S7bet7OSwynRnHslhvVUBly8aIj4eY/5cQqAucUUa5sq6xLD8N27Tl+sQi+kE6KtWu2c0ZhpouflYp55XNMHgU4KeFcVcDtHfJRF6THT6tFcHFNauCHbhfN2F33ANMP4=
 e04a06467e2969c0cc6501335be0406d46ef0 0 iQIVAwUAUpv1oCBXgaxoKi1yAQKOFBAAma2wlsr3w/5NvDwq2rmOrgtNDq1DnNqcXloaOdwegX1z3/N++5uVjLjI0VyguexnwK+7E8rypMZ+4glaiZvIiGPnGMYbG9iOoz5XBhtUHzI5ECYfm5QU81by9VmCIvArDFe5Hlnz4XaXpEGnAwPywD+yzV3/+tyoV7MgsVinCMtbX9OF84/ubWKNzq2810FpQRfYoCOrF8sUed/1TcQrSm1eMB/PnuxjFCFySiR6J7Urd9bJoJIDtdZOQeeHaL5Z8Pcsyzjoe/9oTwJ3L3tl/NMZtRxiQUWtfRA0zvEnQ4QEkZSDMd/JnGiWHPVeP4P92+YN15za9yhneEAtustrTNAmVF2Uh92RIlmkG475HFhvwPJ4DfCx0vU1OOKX/U4c1rifW7H7HaipoaMlsDU2VFsAHcc3YF8ulVt27bH2yUaLGJz7eqpt+3DzZTKp4d/brZA2EkbVgsoYP+XYLbzxfwWlaMwiN3iCnlTFbNogH8MxhfHFWBj6ouikqOz8HlNl6BmSQiUCBnz5fquVpXmW2Md+TDekk+uOW9mvk1QMU62br+Z6PEZupkdTrqKaz+8ZMWvTRct8SiOcu7R11LpfERyrwYGGPei0P2YrEGIWGgXvEobXoPTSl7J+mpOA/rp2Q1zA3ihjgzwtGZZF+ThQXZGIMGaA2YPgzuYRqY8l5oc=
              ca387377df7a3a67dbb90b6336b781cdadc3ef41 0 iQIVAwUAUsThISBXgaxoKi1yAQJpvRAAkRkCWLjHBZnWxX9Oe6t2HQgkSsmn9wMHvXXGFkcAmrqJ86yfyrxLq2Ns0X7Qwky37kOwKsywM53FQlsx9j//Y+ncnGZoObFTz9YTuSbOHGVsTbAruXWxBrGOf1nFTlg8afcbH0jPfQXwxf3ptfBhgsFCzORcqc8HNopAW+2sgXGhHnbVtq6LF90PWkbKjCCQLiX3da1uETGAElrl4jA5Y2i64S1Q/2X+UFrNslkIIRCGmAJ6BnE6KLJaUftpfbN7Br7a3z9xxWqxRYDOinxDgfAPAucOJPLgMVQ0bJIallaRu7KTmIWKIuSBgg1/hgfoX8I1w49WrTGp0gGY140kl8RWwczAz/SB03Xtbl2+h6PV7rUV2K/5g61DkwdVbWqXM9wmJZmvjEKK0qQbBT0By4QSEDNcKKqtaFFwhFzx4dkXph0igHOtXhSNzMd8PsFx/NRn9NLFIpirxfqVDwakpDNBZw4Q9hUAlTPxSFL3vD9/Zs7lV4/dAvvl+tixJEi2k/iv248b/AI1PrPIQEqDvjrozzzYvrS4HtbkUn+IiHiepQaYnpqKoXvBu6btK/nv0GTxB5OwVJzMA1RPDcxIFfZA2AazHjrXiPAl5uWYEddEvRjaCiF8xkQkfiXzLOoqhKQHdwPGcfMFEs9lNR8BrB2ZOajBJc8RPsFDswhT5h4=
              8862469e16f9236208581b20de5f96bd13cc039d 0 iQIVAwUAUt7cLSBXgaxoKi1yAQLOkRAAidp501zafqe+JnDwlf7ORcJc+FgCE6mK1gxDfReCbkMsY7AzspogU7orqfSmr6XXdrDwmk3Y5x3mf44OGzNQjvuNWhqnTgJ7sOcU/lICGQUc8WiGNzHEMFGX9S+K4dpUaBf8Tcl8pU3iArhlthDghW6SZeDFB/FDBaUx9dkdFp6eXrmu4OuGRZEvwUvPtCGxIL7nKNnufI1du/MsWQxvC2ORHbMNtRq6tjA0fLZi4SvbySuYifQRS32BfHkFS5Qu4/40+1k7kd0YFyyQUvIsVa17lrix3zDqMavG8x7oOlqM/axDMBT6DhpdBMAdc5qqf8myz8lwjlFjyDUL6u3Z4/yE0nUrmEudXiXwG0xbVoEN8SCNrDmmvFMt6qdCpdDMkHr2TuSh0Hh4FT5CDkzPI8ZRssv/01j/QvIO3c/xlbpGRPWpsPXEVOz3pmjYN4qyQesnBKWCENsQLy/8s2rey8iQgx2GtsrNw8+wGX6XE4v3QtwUrRe12hWoNrEHWl0xnLv2mvAFqdMAMpFY6EpOKLlE4hoCs2CmTJ2dv6e2tiGTXGU6/frI5iuNRK61OXnH5OjEc8DCGH/GC7NXyDOXOB+7BdBvvf50l2C/vxR2TKgTncLtHeLCrR0GHNHsxqRo1UDwOWur0r7fdfCRvb2tIr5LORCqKYVKd60/BAXjHWc=
 cec5134e9c4bceab6a00c60f52a4f80677a78f2 0 iQIVAwUAUu1lIyBXgaxoKi1yAQIzCBAAizSWvTkWt8+tReM9jUetoSToF+XahLhn381AYdErFCBErX4bNL+vyEj+Jt2DHsAfabkvNBe3k7rtFlXHwpq6POa/ciFGPDhFlplNv6yN1jOKBlMsgdjpn7plZKcLHODOigU7IMlgg70Um8qVrRgQ8FhvbVgR2I5+CD6bucFzqo78wNl9mCIHIQCpGKIUoz56GbwT+rUpEB182Z3u6rf4NWj35RZLGAicVV2A2eAAFh4ZvuC+Z0tXMkp6Gq9cINawZgqfLbzVYJeXBtJC39lHPyp5P3LaEVRhntc9YTwbfkVGjyJZR60iYrieeKpOYRnzgHauPVdgVhkTkBxshmEPY7svKYSQqlj8hLuFa+a3ajbIPrpQAAi1MgtamA991atNqGiSTjdZa9kLQvfdn0k80+gkCxpuO56PhvtdjKsYVRgQMTYmQVQdh3x4WbQOSqTADXXIZUaWxx4RmNSlxY7KD+3lPP09teOD+A3B2cP60bC5NsCfULtQFXQzdC7NvfIyYfYBTZa+Pv6HFkVe10cbnqTt83hBy0D77vdaegPRe56qDNU+GrIG2/rosnlKGFjFoK/pTYkR9uzfkrhEjLwyfkoXlBqY+376W0PC5fP10pJeQBS9DuXpCPlgtyW0Jy1ayCT1YR4QJC4n75vZwTFBFRBhSi0HqFquOgy83+O0Q/k=
              b96cb15ec9e04d8ac5ee08b34fcbbe4200588965 0 iQIVAwUAUxJPlyBXgaxoKi1yAQLIRA//Qh9qzoYthPAWAUNbzybWXC/oMBI2X89NQC7l1ivKhv7cn9L79D8SWXM18q7LTwLdlwOkV/a0NTE3tkQTLvxJpfnRLCBbMOcGiIn/PxsAae8IhMAUbR7qz+XOynHOs60ZhK9X8seQHJRf1YtOI9gYTL/WYk8Cnpmc6xZQ90TNhoPPkpdfe8Y236V11SbYtN14fmrPaWQ3GXwyrvQaqM1F7BxSnC/sbm9+/wprsTa8gRQo7YQL/T5jJQgFiatG3yayrDdJtoRq3TZKtsxw8gtQdfVCrrBibbysjM8++dnwA92apHNUY8LzyptPy7rSDXRrIpPUWGGTQTD+6HQwkcLFtIuUpw4I75SV3z2r6LyOLKzDJUIunKOOYFS/rEIQGxZHxZOBAvbI+73mHAn3pJqm+UAA7R1n7tk3JyQncg50qJlm9zIUPGpNFcdEqak5iXzGYx292VlcE+fbJYeIPWggpilaVUgdmXtMCG0O0uX6C8MDmzVDCjd6FzDJ4GTZwgmWJaamvls85CkZgyN/UqlisfFXub0A1h7qAzBSVpP1+Ti+UbBjlrGX8BMRYHRGYIeIq16elcWwSpLgshjDwNn2r2EdwX8xKU5mucgTzSLprbOYGdQaqnvf6e8IX5WMBgwVW9YdY9yJKSLF7kE1AlM9nfVcXwOK4mHoMvnNgiX3zsw=
 f83fc5cfe715d292069ee8417c83804f6c6c1e4 0 iQIVAwUAUztENyBXgaxoKi1yAQIpkhAAmJj5JRTSn0Dn/OTAHggalw8KYFbAck1X35Wg9O7ku7sd+cOnNnkYfqAdz2m5ikqWHP7aWMiNkNy7Ree2110NqkQVYG/2AJStXBdIOmewqnjDlNt+rbJQN/JsjeKSCy+ToNvhqX5cTM9DF2pwRjMsTXVff307S6/3pga244i+RFAeG3WCUrzfDu641MGFLjG4atCj8ZFLg9DcW5bsRiOs5ZK5Il+UAb2yyoS2KNQ70VLhYULhGtqq9tuO4nLRGN3DX/eDcYfncPCav1GckW4OZKakcbLtAdW0goSgGWloxcM+j2E6Z1JZ9tOTTkFN77EvX0ZWZLmYM7sUN1meFnKbVxrtGKlMelwKwlT252c65PAKa9zsTaRUKvN7XclyxZAYVCsiCQ/V08NXhNgXJXcoKUAeGNf6wruOyvRU9teia8fAiuHJoY58WC8jC4nYG3iZTnl+zNj2A5xuEUpYHhjUfe3rNJeK7CwUpJKlbxopu5mnW9AE9ITfI490eaapRLTojOBDJNqCORAtbggMD46fLeCOzzB8Gl70U2p5P34F92Sn6mgERFKh/10XwJcj4ZIeexbQK8lqQ2cIanDN9dAmbvavPTY8grbANuq+vXDGxjIjfxapqzsSPqUJ5KnfTQyLq5NWwquR9t38XvHZfktkd140BFKwIUAIlKKaFfYXXtM=
 f55b251224f16508dd1311452db7780dafe2b 0 iQIVAwUAU1BmFSBXgaxoKi1yAQJ2Aw//bjK++xJuZCIdktg/i5FxBwoxdbipfTkKsN/YjUwrEmroYM8IkqIsO+U54OGCYWr3NPJ3VS8wUQeJ+NF3ffcjmjC297R9J+X0c5G90DdQUYX44jG/tP8Tqpev4Q7DLCXT26aRwEMdJQpq0eGaqv55E5Cxnyt3RrLCqe7RjPresZFg7iYrro5nq8TGYwBhessHXnCix9QI0HtXiLpms+0UGz8Sbi9nEYW+M0OZCyO1TvykCpFzEsLNwqqtFvhOMD/AMiWcTKNUpjmOn3V83xjWl+jnDUt7BxJ7n1efUnlwl4IeWlSUb73q/durtaymb97cSdKFmXHv4pdAShQEuEpVVGO1WELsKoXmbj30ItTW2V3KvNbjFsvIdDo7zLCpXyTq1HC56W7QCIMINX2qT+hrAMWC12tPQ05f89Cv1+jpk6eOPFqIHFdi663AjyrnGll8nwN7HJWwtA5wTXisu3bec51FAq4yJTzPMtOE9spz36E+Go2hZ1cAv9oCSceZcM0wB8KiMfaZJKNZNZk1jvsdiio4CcdASOFQPOspz07GqQxVP7W+F1Oz32LgwcNAEAS/f3juwDj45GYfAWJrTh3dnJy5DTD2LVC7KtkxxUVkWkqxivnDB9anj++FN9eyekxzut5eFED+WrCfZMcSPW0ai7wbslhKUhCwSf/v3DgGwsM=
 ac506c6ababe86985b932f4948837c0891b5 0 iQIVAwUAU2LO/CBXgaxoKi1yAQI/3w/7BT/VRPyxey6tYp7i5cONIlEB3gznebGYwm0SGYNE6lsvS2VLh6ztb+j4eqOadr8Ssna6bslBx+dVsm+VuJ+vrNLMucD5Uc+fhn6dAfVqg+YBzUEaedI5yNsJizcJUDI7hUVsxiPiiYd9hchCWJ+z2tVt2jCyG2lMV2rbW36AM89sgz/wn5/AaAFsgoS6up/uzA3Tmw+qZSO6dZChb4Q8midIUWEbNzVhokgYcw7/HmjmvkvV9RJYiG8aBnMdQmxTE69q2dTjnnDL6wu61WU2FpTN09HRFbemUqzAfoJp8MmXq6jWgfLcm0cI3kRo7ZNpnEkmVKsfKQCXXiaR4alt9IQpQ6Jl7LSYsYI+D4ejpYysIsZyAE8qzltYhBKJWqO27A5V4WdJsoTgA/RwKfPRlci4PY8I4N466S7PBXVz/Cc5EpFkecvrgceTmBafb8JEi+gPiD2Po4vtW3bCeV4xldiEXHeJ77byUz7fZU7jL78SjJVOCCQTJfKZVr36kTz3KlaOz3E700RxzEFDYbK7I41mdANeQBmNNbcvRTy5ma6W6I3McEcAH4wqM5fFQ8YS+QWJxk85Si8KtaDPqoEdC/0dQPavuU/jAVjhV8IbmmkOtO7WvOHQDBtrR15yMxGMnUwMrPHaRNKdHNYRG0LL7lpCtdMi1mzLQgHYY9SRYvI=
 c80ee5b3cb3684fa8edc61501b3506d02eb10 0 iQIVAwUAU4uX5CBXgaxoKi1yAQLpdg/+OxulOKwZN+Nr7xsRhUijYjyAElRf2mGDvMrbAOA2xNf85DOXjOrX5TKETumf1qANA5cHa1twA8wYgxUzhx30H+w5EsLjyeSsOncRnD5WZNqSoIq2XevT0T4c8xdyNftyBqK4h/SC/t2h3vEiSCUaGcfNK8yk4XO45MIk4kk9nlA9jNWdA5ZMLgEFBye2ggz0JjEAPUkVDqlr9sNORDEbnwZxGPV8CK9HaL/I8VWClaFgjKQmjqV3SQsNFe2XPffzXmIipFJ+ODuXVxYpAsvLiGmcfuUfSDHQ4L9QvjBsWe1PgYMr/6CY/lPYmR+xW5mJUE9eIdN4MYcXgicLrmMpdF5pToNccNCMtfa6CDvEasPRqe2bDzL/Q9dQbdOVE/boaYBlgmYLL+/u+dpqip9KkyGgbSo9uJzst1mLTCzJmr5bw+surul28i9HM+4+Lewg4UUdHLz46no1lfTlB5o5EAhiOZBTEVdoBaKfewVpDa/aBRvtWX7UMVRG5qrtA0sXwydN00Jaqkr9m20W0jWjtc1ZC72QCrynVHOyfIb2rN98rnuy2QN4bTvjNpNjHOhhhPTOoVo0YYPdiUupm46vymUTQCmWsglU4Rlaa3vXneP7JenL5TV8WLPs9J28lF0IkOnyBXY7OFcpvYO1euu7iR1VdjfrQukMyaX18usymiA=
 d8cd3d0e83c7336c0cb45a9f88638363f993848 0 iQIVAwUAU7OLTCBXgaxoKi1yAQJ+pw/+M3yOesgf55eo3PUTZw02QZxDyEg9ElrRc6664/QFXaJuYdz8H3LGG/NYs8uEdYihiGpS1Qc70jwd1IoUlrCELsaSSZpzWQ+VpQFX29aooBoetfL+8WgqV8zJHCtY0E1EBg/Z3ZL3n2OS++fVeWlKtp5mwEq8uLTUmhIS7GseP3bIG/CwF2Zz4bzhmPGK8V2s74aUvELZLCfkBE1ULNs7Nou1iPDGnhYOD53eq1KGIPlIg1rnLbyYw5bhS20wy5IxkWf2eCaXfmQBTG61kO5m3nkzfVgtxmZHLqYggISTJXUovfGsWZcp5a71clCSMVal+Mfviw8L/UPHG0Ie1c36djJiFLxM0f2HlwVMjegQOZSAeMGg1YL1xnIys2zMMsKgEeR+JISTal1pJyLcT9x5mr1HCnUczSGXE5zsixN+PORRnZOqcEZTa2mHJ1h5jJeEm36B/eR57BMJG+i0QgZqTpLzYTFrp2eWokGMjFB1MvgAkL2YoRsw9h6TeIwqzK8mFwLi28bf1c90gX9uMbwY/NOqGzfQKBR9bvCjs2k/gmJ+qd5AbC3DvOxHnN6hRZUqNq76Bo4F+CUVcjQ/NXnfnOIVNbILpl5Un5kl+8wLFM+mNxDxduajaUwLhSHZofKmmCSLbuuaGmQTC7a/4wzhQM9e5dX0X/8sOo8CptW7uw4=
 c36dc6cd61a0e1b563f1d51e55bdf4dacf12162 0 iQIVAwUAU8n97yBXgaxoKi1yAQKqcA/+MT0VFoP6N8fHnlxj85maoM2HfZbAzX7oEW1B8F1WH6rHESHDexDWIYWJ2XnEeTD4GCXN0/1p+O/I0IMPNzqoSz8BU0SR4+ejhRkGrKG7mcFiF5G8enxaiISn9nmax6DyRfqtOQBzuXYGObXg9PGvMS6zbR0SorJK61xX7fSsUNN6BAvHJfpwcVkOrrFAIpEhs/Gh9wg0oUKCffO/Abs6oS+P6nGLylpIyXqC7rKZ4uPVc6Ljh9DOcpV4NCU6kQbNE7Ty79E0/JWWLsHOEY4F4WBzI7rVh7dOkRMmfNGaqvKkuNkJOEqTR1o1o73Hhbxn4NU7IPbVP/zFKC+/4QVtcPk2IPlpK1MqA1H2hBNYZhJlNhvAa7LwkIxM0916/zQ8dbFAzp6Ay/t/L0tSEcIrudTz2KTrY0WKw+pkzB/nTwaS3XZre6H2B+gszskmf1Y41clkIy/nH9K7zBuzANWyK3+bm40vmMoBbbnsweUAKkyCwqm4KTyQoYQWzu/ZiZcI+Uuk/ajJ9s7EhJbIlSnYG9ttWL/IZ1h+qPU9mqVO9fcaqkeL/NIRh+IsnzaWo0zmHU1bK+/E29PPGGf3v6+IEJmXg7lvNl5pHiMd2tb7RNO/UaNSv1Y2E9naD4FQwSWo38GRBcnRGuKCLdZNHGUR+6dYo6BJCGG8wtZvNXb3TOo=
 e49892020336491cdc6945885c4de26ffa8b 0 iQIVAwUAU9whUCBXgaxoKi1yAQJDKxAAoGzdHXV/BvZ598VExEQ8IqkmBVIP1QZDVBr/orMc1eFM4tbGKxumMGbqgJsg+NetI0irkh/YWeJQ13lT4Og72iJ+4UC9eF9pcpUKr/0eBYdU2N/p2MIbVNWh3aF5QkbuQpSri0VbHOWkxqwoqrrwXEjgHaKYP4PKh+Dzukax4yzBUIyzAG38pt4a8hbjnozCl2uAikxk4Ojg+ZufhPoZWgFEuYzSfK5SrwVKOwuxKYFGbbVGTQMIXLvBhOipAmHp4JMEYHfG85kwuyx/DCDbGmXKPQYQfClwjJ4ob/IwG8asyMsPWs+09vrvpVO08HBuph3GjuiWJ1fhEef/ImWmZdQySI9Y4SjwP4dMVfzLCnY+PYPDM9Sq/5Iee13gI2lVM2NtAfQZPXh9l8u6SbCir1UhMNMx0qVMkqMAATmiZ+ETHCO75q4Wdcmnv5fk2PbvaGBVtrHGeiyuz5mK/j4cMbd0R9R0hR1PyC4dOhNqOnbqELNIe0rKNByG1RkpiQYsqZTU6insmnZrv4fVsxfA4JOObPfKNT4oa24MHS73ldLFCfQAuIxVE7RDJJ3bHeh/yO6Smo28FuVRldBl5e+wj2MykS8iVcuSa1smw6gJ14iLBH369nlR3fAAQxI0omVYPDHLr7SsH3vJasTaCD7V3SL4lW6vo/yaAh4ImlTAE+Y=
 dc91146f35369949ea56b40172308158b59063a 0 iQIVAwUAVAUgJyBXgaxoKi1yAQJkEg/9EXFZvPpuvU7AjII1dlIT8F534AXrO30+H6hweg+h2mUCSb/mZnbo3Jr1tATgBWbIKkYmmsiIKNlJMFNPZTWhImGcVA93t6v85tSFiNJRI2QP9ypl5wTt2KhiS/s7GbUYCtPDm6xyNYoSvDo6vXJ5mfGlgFZY5gYLwEHq/lIRWLWD4EWYWbk5yN+B7rHu6A1n3yro73UR8DudEhYYqC23KbWEqFOiNd1IGj3UJlxIHUE4AcDukxbfiMWrKvv1kuT/vXak3X7cLXlO56aUbMopvaUflA3PSr3XAqynDd69cxACo/T36fuwzCQN4ICpdzGTos0rQALSr7CKF5YP9LMhVhCsOn0pCsAkSiw4HxxbcHQLl+t+0rchNysc4dWGwDt6GAfYcdm3fPtGFtA3qsN8lOpCquFH3TAZ3TrIjLFoTOk6s1xX1x5rjP/DAHc/y3KZU0Ffx3TwdQEEEIFaAXaxQG848rdfzV42+dnFnXh1G/MIrKAmv3ZSUkQ3XJfGc7iu82FsYE1NLHriUQDmMRBzCoQ1Rn1Kji119Cxf5rsMcQ6ZISR1f0jDCUS/qxlHvSqETLp8H63NSUfvuKSC7uC6pGvq9XQm1JRNO5UuJfK6tHzy0jv9bt2IRo2xbmvpDu9L5oHHd3JePsAmFmbrFf/7Qem3JyzEvRcpdcdHtefxcxc=
              f768c888aaa68d12dd7f509dcc7f01c9584357d0 0 iQIVAwUAVCxczSBXgaxoKi1yAQJYiA/9HnqKuU7IsGACgsUGt+YaqZQumg077Anj158kihSytmSts6xDxqVY1UQB38dqAKLJrQc7RbN0YK0NVCKZZrx/4OqgWvjiL5qWUJKqQzsDx4LGTUlbPlZNZawW2urmmYW6c9ZZDs1EVnVeZMDrOdntddtnBgtILDwrZ8o3U7FwSlfnm03vTkqUMj9okA3AsI8+lQIlo4qbqjQJYwvUC1ZezRdQwaT1LyoWUgjmhoZ1XWcWKOs9baikaJr6fMv8vZpwmaOY1+pztxYlROeSPVWt9P6yOf0Hi/2eg8AwSZLaX96xfk9IvXUSItg/wjTWP9BhnNs/ulwTnN8QOgSXpYxH4RXwsYOyU7BvwAekA9xi17wuzPrGEliScplxICIZ7jiiwv/VngMvM9AYw2mNBvZt2ZIGrrLaK6pq/zBm5tbviwqt5/8U5aqO8k1O0e4XYm5WmQ1c2AkXRO+xwvFpondlSF2y0flzf2FRXP82QMfsy7vxIP0KmaQ4ex+J8krZgMjNTwXh2M4tdYNtu5AehJQEP3l6giy2srkMDuFLqoe1yECjVlGdgA86ve3J/84I8KGgsufYMhfQnwHHGXCbONcNsDvO0QOee6CIQVcdKCG7dac3M89SC6Ns2CjuC8BIYDRnxbGQb7Fvn4ZcadyJKKbXQJzMgRV25K6BAwTIdvYAtgU=
 f8d16af8cae246fa5a48e723d48d58b015aed94 0 iQIVAwUAVEL0XyBXgaxoKi1yAQJLkRAAjZhpUju5nnSYtN9S0/vXS/tjuAtBTUdGwc0mz97VrM6Yhc6BjSCZL59tjeqQaoH7Lqf94pRAtZyIB2Vj/VVMDbM+/eaoSr1JixxppU+a4eqScaj82944u4C5YMSMC22PMvEwqKmy87RinZKJlFwSQ699zZ5g6mnNq8xeAiDlYhoF2QKzUXwnKxzpvjGsYhYGDMmVS1QPmky4WGvuTl6KeGkv8LidKf7r6/2RZeMcq+yjJ7R0RTtyjo1cM5dMcn/jRdwZxuV4cmFweCAeoy5guV+X6du022TpVndjOSDoKiRgdk7pTuaToXIy+9bleHpEo9bwKx58wvOMg7sirAYjrA4Xcx762RHiUuidTTPktm8sNsBQmgwJZ8Pzm+8TyHjFGLnBfeiDbQQEdLCXloz0jVOVRflDfMays1WpAYUV8XNOsgxnD2jDU8L0NLkJiX5Y0OerGq9AZ+XbgJFVBFhaOfsm2PEc3jq00GOLzrGzA+4b3CGpFzM3EyK9OnnwbP7SqCGb7PJgjmQ7IO8IWEmVYGaKtWONSm8zRLcKdH8xuk8iN1qCkBXMty/wfTEVTkIlMVEDbslYkVfj0rAPJ8B37bfe0Yz4CEMkCmARIB1rIOpMhnavXGuD50OP2PBBY/8DyC5aY97z9f04na/ffk+l7rWaHihjHufKIApt5OnfJ1w=
              ced632394371a36953ce4d394f86278ae51a2aae 0 iQIVAwUAVFWpfSBXgaxoKi1yAQLCQw//cvCi/Di3z/2ZEDQt4Ayyxv18gzewqrYyoElgnEzr5uTynD9Mf25hprstKla/Y5C6q+y0K6qCHPimGOkz3H+wZ2GVUgLKAwMABkfSb5IZiLTGaB2DjAJKZRwB6h43wG/DSFggE3dYszWuyHW88c72ZzVF5CSNc4J1ARLjDSgnNYJQ6XdPw3C9KgiLFDXzynPpZbPg0AK5bdPUKJruMeIKPn36Hx/Tv5GXUrbc2/lcnyRDFWisaDl0X/5eLdA+r3ID0cSmyPLYOeCgszRiW++KGw+PPDsWVeM3ZaZ9SgaBWU7MIn9A7yQMnnSzgDbN+9v/VMT3zbk1WJXlQQK8oA+CCdHH9EY33RfZ6ST/lr3pSQbUG1hdK6Sw+H6WMkOnnEk6HtLwa4xZ3HjDpoPkhVV+S0C7D5WWOovbubxuBiW5v8tK4sIOS6bAaKevTBKRbo4Rs6qmS/Ish5Q+z5bKst80cyEdi4QSoPZ/W+6kh1KfOprMxynwPQhtEcDYW2gfLpgPIM7RdXPKukLlkV2qX3eF/tqApGU4KNdP4I3N80Ri0h+6tVU/K4TMYzlRV3ziLBumJ4TnBrTHU3X6AfZUfTgslQzokX8/7a3tbctX6kZuJPggLGisdFSdirHbrUc+y5VKuJtPr+LxxgZKRFbs2VpJRem6FvwGNyndWLv32v0GMtQ=
 c58303fb0ec020907af28b9e486be299ba043 0 iQIVAwUAVGKawCBXgaxoKi1yAQL7zxAAjpXKNvzm/PKVlTfDjuVOYZ9H8w9QKUZ0vfrNJrN6Eo6hULIostbdRc25FcMWocegTqvKbz3IG+L2TKOIdZJS9M9QS4URybUd37URq4Jai8kMiJY31KixNNnjO2G1B39aIXUhY+EPx12aY31/OVy4laXIVtN6qpSncjo9baXSOMZmx6RyA1dbyfwXRjT/aODCGHZXgLJHS/kHlkCsThVlqYQ4rUCDkXIeMqIGF1CR0KjfmKpp1fS14OMgpLgdnt9+pnBZ+qcf1YdpOeQob1zwunjMYOyYC74FyOTdwaynU2iDsuBrmkE8kgEedIn7+WWe9fp/6TQJMVOeTQPZBNSRRSUYCw5Tg/0L/+jLtzjc2mY4444sDPbR7scrtU+/GtvlR5z0Y5pofwEdFME7PZNOp9a4kMiSa7ZERyGdN7U1pDu9JU6BZRz+nPzW217PVnTF7YFV/GGUzMTk9i7EZb5M4T9r9gfxFSMPeT5ct712CdBfyRlsSbSWk8XclTXwW385kLVYNDtOukWrvEiwxpA14Xb/ZUXbIDZVf5rP2HrZHMkghzeUYPjRn/IlgYUt7sDNmqFZNIc9mRFrZC9uFQ/Nul5InZodNODQDM+nHpxaztt4xl4qKep8SDEPAQjNr8biC6T9MtLKbWbSKDlqYYNv0pb2PuGub3y9rvkF1Y05mgM=
              902554884335e5ca3661d63be9978eb4aec3f68a 0 iQIVAwUAVH0KMyBXgaxoKi1yAQLUKxAAjgyYpmqD0Ji5OQ3995yX0dmwHOaaSuYpq71VUsOMYBskjH4xE2UgcTrX8RWUf0E+Ya91Nw3veTf+IZlYLaWuOYuJPRzw+zD1sVY8xprwqBOXNaA7n8SsTqZPSh6qgw4S0pUm0xJUOZzUP1l9S7BtIdJP7KwZ7hs9YZev4r9M3G15xOIPn5qJqBAtIeE6f5+ezoyOpSPZFtLFc4qKQ/YWzOT5uuSaYogXgVByXRFaO84+1TD93LR0PyVWxhwU9JrDU5d7P/bUTW1BXdjsxTbBnigWswKHC71EHpgz/HCYxivVL30qNdOm4Fow1Ec2GdUzGunSqTPrq18ScZDYW1x87f3JuqPM+ce/lxRWBBqP1yE30/8l/Us67m6enWXdGER8aL1lYTGOIWAhvJpfzv9KebaUq1gMFLo6j+OfwR3rYPiCHgi20nTNBa+LOceWFjCGzFa3T9UQWHW/MBElfAxK65uecbGRRYY9V1/+wxtTUiS6ixpmzL8S7uUd5n6oMaeeMiD82NLgPIbMyUHQv6eFEcCj0U9NT2uKbFRmclMs5V+8D+RTCsLJ55R9PD5OoRw/6K/coqqPShYmJvgYsFQPzXVpQdCRae31xdfGFmd5KUetqyrT+4GUdJWzSm0giSgovpEJNxXglrvNdvSO7fX3R1oahhwOwtGqMwNilcK+iDw=
 dad422ecc5adb63d9fa649eeb8e05a5f9bc4900 0 iQIVAwUAVJNALCBXgaxoKi1yAQKgmw/+OFbHHOMmN2zs2lI2Y0SoMALPNQBInMBq2E6RMCMbfcS9Cn75iD29DnvBwAYNWaWsYEGyheJ7JjGBiuNKPOrLaHkdjG+5ypbhAfNDyHDiteMsXfH7D1L+cTOAB8yvhimZHOTTVF0zb/uRyVIPNowAyervUVRjDptzdfcvjUS+X+/Ufgwms6Y4CcuzFLFCxpmryJhLtOpwUPLlzIqeNkFOYWkHanCgtZX03PNIWhorH3AWOc9yztwWPQ+kcKl3FMlyuNMPhS/ElxSF6GHGtreRbtP+ZLoSIOMb2QBKpGDpZLgJ3JQEHDcZ0h5CLZWL9dDUJR3M8pg1qglqMFSWMgRPTzxPS4QntPgT/Ewd3+U5oCZUh052fG41OeCZ0CnVCpqi5PjUIDhzQkONxRCN2zbjQ2GZY7glbXoqytissihEIVP9m7RmBVq1rbjOKr+yUetJ9gOZcsMtZiCEq4Uj2cbA1x32MQv7rxwAgQP1kgQ62b0sN08HTjQpI7/IkNALLIDHoQWWr45H97i34qK1dd5uCOnYk7juvhGNX5XispxNnC01/CUVNnqChfDHpgnDjgT+1H618LiTgUAD3zo4IVAhCqF5XWsS4pQEENOB3Msffi62fYowvJx7f/htWeRLZ2OA+B85hhDiD4QBdHCRoz3spVp0asNqDxX4f4ndj8RlzfM=
 a3a71d75396f5d4cf6935ae7d9ba5407a547 0 iQIVAwUAVKXKYCBXgaxoKi1yAQIfsA/+PFfaWuZ6Jna12Y3MpKMnBCXYLWEJgMNlWHWzwU8lD26SKSlvMyHQsVZlkld2JmFugUCn1OV3OA4YWT6BA7VALq6Zsdcu5Dc8LRbyajBUkzGRpOUyWuFzjkCpGVbrQzbCR/bel/BBXzSqL4ipdtWgJ4y+WpZIhWkNXclBkR52b5hUTjN9vzhyhVVI7eURGwIEf7vVs1fDOcEGtaGY/ynzMTzyxIDsEEygCZau86wpKlYlqhCgxKDyzyGfpH3B1UlNGFt1afW8AWe1eHjdqC7TJZpMqmQ/Ju8vco8Xht6OXw4ZLHj7y39lpccfKTBLiK/cAKSg+xgyaH/BLhzoEkNAwYSFAB4i4IoV0KUC8nFxHfsoswBxJnMqU751ziMrpZ/XHZ1xQoEOdXgz2I04vlRn8xtynOVhcgjoAXwtbia7oNh/qCH/hl5/CdAtaawuCxJBf237F+cwur4PMAAvsGefRfZco/DInpr3qegr8rwInTxlO48ZG+o5xA4TPwT0QQTUjMdNfC146ZSbp65wG7VxJDocMZ8KJN/lqPaOvX+FVYWq4YnJhlldiV9DGgmym1AAaP0D3te2GcfHXpt/f6NYUPpgiBHy0GnOlNcQyGnnONg1A6oKVWB3k7WP28+PQbQEiCIFk2nkf5VZmye7OdHRGKOFfuprYFP1WwTWnVoNX9c=
              db8e3f7948b1fdeb9ad12d448fc3525759908b9f 0 iQIVAwUAVLsaciBXgaxoKi1yAQKMIA//a90/GvySL9UID+iYvzV2oDaAPDD0T+4Xs43I7DT5NIoDz+3yq2VV54XevQe5lYiURmsb/Q9nX2VR/Qq1J9c/R6Gy+CIfmJ3HzMZ0aAX8ZlZgQPYZKh/2kY5Ojl++k6MTqbqcrICNs4+UE/4IAxPyOfu5gy7TpdJmRZo2J3lWVC2Jbhd02Mzb+tjtfbOM+QcQxPwt9PpqmQszJceyVYOSm3jvD1uJdSOC04tBQrQwrxktQ09Om0LUMMaB5zFXpJtqUzfw7l4U4AaddEmkd3vUfLtHxc21RB01c3cpe2dJnjifDfwseLsI8rS4jmi/91c74TeBatSOhvbqzEkm/p8xZFXE4Uh+EpWjTsVqmfQaRq6NfNCR7I/kvGv8Ps6w8mg8uX8fd8lx+GJbodj+Uy0X3oqHyqPMky/df5i79zADBDuz+yuxFfDD9i22DJPIYcilfGgwpIUuO2lER5nSMVmReuWTVBnT6SEN66Q4KR8zLtIRr+t1qUUCy6wYbgwrdHVCbgMF8RPOVZPjbs17RIqcHjch0Xc7bShKGhQg4WHDjXHK61w4tOa1Yp7jT6COkl01XC9BLcGxJYKFvNCbeDZQGvVgJNoEvHxBxD9rGMVRjfuxeJawc2fGzZJn0ySyLDW0pfd4EJNgTh9bLdPjWz2VlXqn4A6bgaLgTPqjmN0VBXw=
              fbdd5195528fae4f41feebc1838215c110b25d6a 0 iQIVAwUAVM7fBCBXgaxoKi1yAQKoYw/+LeIGcjQmHIVFQULsiBtPDf+eGAADQoP3mKBy+eX/3Fa0qqUNfES2Q3Y6RRApyZ1maPRMt8BvvhZMgQsu9QIrmf3zsFxZGFwoyrIj4hM3xvAbEZXqmWiR85/Ywd4ImeLaZ0c7mkO1/HGF1n2Mv47bfM4hhNe7VGJSSrTY4srFHDfk4IG9f18DukJVzRD9/dZeBw6eUN1ukuLEgQAD5Sl47bUdKSetglOSR1PjXfZ1hjtz5ywUyBc5P9p3LC4wSvlcJKl22zEvB3L0hkoDcPsdIPEnJAeXxKlR1rQpoA3fEgrstGiSNUW/9Tj0VekAHLO95SExmQyoG/AhbjRRzIj4uQ0aevCJyiAhkv+ffOSf99PMW9L1k3tVjLhpMWEz9BOAWyX7cDFWj5t/iktI046O9HGN9SGVx18e9xM6pEgRcLA2TyjEmtkA4jX0JeN7WeCweMLiSxyGP7pSPSJdpJeXaFtRpSF62p/G0Z5wN9s05LHqDyqNVtCvg4WjkuV5LZSdLbMcYBWGBxQzCG6qowXFXIawmbaFiBZwTfOgNls9ndz5RGupAaxY317prxPFv/pXoesc1P8bdK09ZvjhbmmD66Q/BmS2dOMQ8rXRjuVdlR8j2QBtFZxekMcRD02nBAVnwHg1VWQMIRaGjdgmW4wOkirWVn7me177FnBxrxW1tG4=
 b4ed033390bf6e2879c8f5c28c84e1ee3b87231 0 iQIVAwUAVPQL9CBXgaxoKi1yAQJIXxAAtD2hWhaKa+lABmCOYG92FE/WdqY/91Xv5atTL8Xeko/MkirIKZiOuxNWX+J34TVevINZSWmMfDSc5TkGxktL9jW/pDB/CXn+CVZpxRabPYFH9HM2K3g8VaTV1MFtV2+feOMDIPCmq5ogMF9/kXjmifiEBrJcFsE82fdexJ3OHoOY4iHFxEhh3GzvNqEQygk4VeU6VYziNvSQj9G//PsK3Bmk7zm5ScsZcMVML3SIYFuej1b1PI1v0N8mmCRooVNBGhD/eA0iLtdh/hSb9s/8UgJ4f9HOcx9zqs8V4i14lpd/fo0+yvFuVrVbWGzrDrk5EKLENhVPwvc1KA32PTQ4Z9u7VQIBIxq3K5lL2VlCMIYc1BSaSQBjuiLm8VdN6iDuf5poNZhk1rvtpQgpxJzh362dlGtR/iTJuLCeW7gCqWUAorLTeHy0bLQ/jSOeTAGys8bUHtlRL4QbnhLbUmJmRYVvCJ+Yt1aTgTSNcoFjoLJarR1169BXgdCA38BgReUL6kB224UJSTzB1hJUyB2LvCWrXZMipZmR99Iwdq7MePD3+AoSIXQNUMY9blxuuF5x7W2ikNXmVWuab4Z8rQRtmGqEuIMBSunxAnZSn+i8057dFKlq+/yGy+WW3RQg+RnLnwZs1zCDTfu98/GT5k5hFpjXZeUWWiOVwQJ5HrqncCw=
 a92bbd02e5e3a625e0820389b47786b02b2cea 0 iQIVAwUAVPSP9SBXgaxoKi1yAQLkBQ//dRQExJHFepJfZ0gvGnUoYI4APsLmne5XtfeXJ8OtUyC4a6RylxA5BavDWgXwUh9BGhOX2cBSz1fyvzohrPrvNnlBrYKAvOIJGEAiBTXHYTxHINEKPtDF92Uz23T0Rn/wnSvvlbWF7Pvd+0DMJpFDEyr9n6jvVLR7mgxMaCqZbVaB1W/wTwDjni780WgVx8OPUXkLx3/DyarMcIiPeI5UN+FeHDovTsBWFC95msFLm80PMRPuHOejWp65yyEemGujZEPO2D5VVah7fshM2HTz63+bkEBYoqrftuv3vXKBRG78MIrUrKpqxmnCKNKDUUWJ4yk3+NwuOiHlKdly5kZ7MNFaL73XKo8HH287lDWz0lIazs91dQA9a9JOyTsp8YqGtIJGGCbhrUDtiQJ199oBU84mw3VH/EEzm4mPv4sW5fm7BnnoH/a+9vXySc+498rkdLlzFwxrQkWyJ/pFOx4UA3mCtGQK+OSwLPc+X4SRqA4fiyqKxVAL1kpLTSDL3QA82I7GzBaXsxUXzS4nmteMhUyzTdwAhKVydL0gC3d7NmkAFSyRjdGzutUUXshYxg0ywRgYebe8uzJcTj4nNRgaalYLdg3guuDulD+dJmILsrcLmA6KD/pvfDn8PYt+4ZjNIvN2E9GF6uXDu4Ux+AlOTLk9BChxUF8uBX9ev5cvWtQ=
 e2e9a0750f91a6fe0ad88e4de34f8efefdcab08 0 iQIVAwUAVRw4nyBXgaxoKi1yAQIFExAAkbCPtLjQlJvPaYCL1KhNR+ZVAmn7JrFH3XhvR26RayYbs4NxR3W1BhwhDy9+W+28szEx1kQvmr6t1bXAFywY0tNJOeuLU7uFfmbgAfYgkQ9kpsQNqFYkjbCyftw0S9vX9VOJ9DqUoDWuKfX7VzjkwE9dCfKI5F+dvzxnd6ZFjB85nyHBQuTZlzXl0+csY212RJ2G2j/mzEBVyeZj9l7Rm+1X8AC1xQMWRJGiyd0b7nhYqoOcceeJFAV1t9QO4+gjmkM5kL0orjxTnuVsxPTxcC5ca1BfidPWrZEto3duHWNiATGnCDylxxr52BxCAS+BWePW9J0PROtw1pYaZ9pF4N5X5LSXJzqX7ZiNGckxqIjry09+Tbsa8FS0VkkYBEiGotpuo4Jd05V6qpXfW2JqAfEVo6X6aGvPM2B7ZUtKi30I4J+WprrOP3WgZ/ZWHe1ERYKgjDqisn3t/D40q30WQUeQGltGsOX0Udqma2RjBugO5BHGzJ2yer4GdJXg7q1OMzrjAEuz1IoKvIB/o1pg86quVA4H2gQnL1B8t1M38/DIafyw7mrEY4Z3GL44Reev63XVvDE099Vbhqp7ufwq81Fpq7Xxa5vsr9SJ+8IqqQr8AcYSuK3G3L6BmIuSUAYMRqgl35FWoWkGyZIG5c6K6zI8w5Pb0aGi6Lb2Wfb9zbc=
              e89f909edffad558b56f4affa8239e4832f88de0 0 iQIVAwUAVTBozCBXgaxoKi1yAQLHeg/+IvfpPmG7OSqCoHvMVETYdrqT7lKCwfCQWMFOC/2faWs1n4R/qQNm6ckE5OY888RK8tVQ7ue03Pg/iyWgQlYfS7Njd3WPjS4JsnEBxIvuGkIu6TPIXAUAH0PFTBh0cZEICDpPEVT2X3bPRwDHA+hUE9RrxM5zJ39Fpk/pTYCjQ9UKfEhXlEfka75YB39g2Y/ssaSbn5w/tAAx8sL72Y4G96D4IV2seLHZhB3VQ7UZKThEWn6UdVOoKj+urIwGaBYMeekGVtHSh6fnHOw3EtDO9mQ5HtAz2Bl4CwRYN8eSN+Dwgr+mdk8MWpQQJ+i1A8jUhUp8gn1Pe5GkIH4CWZ9+AvLLnshe2MkVaTT1g7EQk37tFkkdZDRBsOHIvpF71B9pEA1gMUlX4gKgh5YwukgpQlDmFCfY7XmX6eXw9Ub+EckEwYuGMz7Fbwe9J/Ce4DxvgJgq3/cu/jb3bmbewH6tZmcrlqziqqA8GySIwcURnF1c37e7+e7x1jhFJfCWpHzvCusjKhUp9tZsl9Rt1Bo/y41QY+avY7//ymhbwTMKgqjzCYoA+ipF4JfZlFiZF+JhvOSIFb0ltkfdqKD+qOjlkFaglvQU1bpGKLJ6cz4Xk2Jqt5zhcrpyDMGVv9aiWywCK2ZP34RNaJ6ZFwzwdpXihqgkm5dBGoZ4ztFUfmjXzIg=
 cc6036bca532e06681c5a8fa37efaa812de67b5 0 iQIVAwUAVUP0xCBXgaxoKi1yAQLIChAAme3kg1Z0V8t5PnWKDoIvscIeAsD2s6EhMy1SofmdZ4wvYD1VmGC6TgXMCY7ssvRBhxqwG3GxwYpwELASuw2GYfVot2scN7+b8Hs5jHtkQevKbxarYni+ZI9mw/KldnJixD1yW3j+LoJFh/Fu6GD2yrfGIhimFLozcwUu3EbLk7JzyHSn7/8NFjLJz0foAYfcbowU9/BFwNVLrQPnsUbWcEifsq5bYso9MBO9k+25yLgqHoqMbGpJcgjubNy1cWoKnlKS+lOJl0/waAk+aIjHXMzFpRRuJDjxEZn7V4VdV5d23nrBTcit1BfMzga5df7VrLPVRbom1Bi0kQ0BDeDex3hHNqHS5X+HSrd/njzP1xp8twG8hTE+njv85PWoGBTo1eUGW/esChIJKA5f3/F4B9ErgBNNOKnYmRgxixd562OWAwAQZK0r0roe2H/Mfg2VvgxT0kHd22NQLoAv0YI4jcXcCFrnV/80vHUQ8AsAYAbkLcz1jkfk3YwYDP8jbJCqcwJRt9ialYKJwvXlEe0TMeGdq7EjCO0z/pIpu82k2R/C0FtCFih3bUvJEmWoVVx8UGkDDQEORLbzxQCt0IOiQGFcoCCxgQmL0x9ZoljCWg5vZuuhU4uSOuRTuM+aa4xoLkeOcvgGRSOXrqfkV8JpWKoJB4dmY2qSuxw8LsAAzK0=
              ed18f4acf435a2824c6f49fba40f42b9df5da7ad 0 iQIVAwUAVWy9mCBXgaxoKi1yAQIm+Q/+I/tV8DC51d4f/6T5OR+motlIx9U5za5p9XUUzfp3tzSY2PutVko/FclajVdFekZsK5pUzlh/GZhfe1jjyEEIr3UC3yWk8hMcvvS+2UDmfy81QxN7Uf0kz4mZOlME6d/fYDzf4cDKkkCXoec3kyZBw7L84mteUcrJoyb5K3fkQBrK5CG/CV7+uZN6b9+quKjtDhDEkAyc6phNanzWNgiHGucEbNgXsKM01HmV1TnN4GXTKx8y2UDalIJOPyes2OWHggibMHbaNnGnwSBAK+k29yaQ5FD0rsA+q0j3TijA1NfqvtluNEPbFOx/wJV4CxonYad93gWyEdgU34LRqqw1bx7PFUvew2/T3TJsxQLoCt67OElE7ScG8evuNEe8/4r3LDnzYFx7QMP5r5+B7PxVpj/DT+buS16BhYS8pXMMqLynFOQkX5uhEM7mNC0JTXQsBMHSDAcizVDrdFCF2OSfQjLpUfFP1VEWX7EInqj7hZrd+GE7TfBD8/rwSBSkkCX2aa9uKyt6Ius1GgQUuEETskAUvvpsNBzZxtvGpMMhqQLGlJYnBbhOmsbOyTSnXU66KJ5e/H3O0KRrF09i74v30DaY4uIH8xG6KpSkfw5s/oiLCtagfc0goUvvojk9pACDR3CKM/jVC63EVp2oUcjT72jUgSLxBgi7siLD8IW86wc=
 cd0ddac49c1125b2e013aa2ff18ecbd4dd954 0 iQIVAwUAVZRtzSBXgaxoKi1yAQJVLhAAtfn+8OzHIp6wRC4NUbkImAJRLsNTRPKeRSWPCF5O5XXQ84hp+86qjhndIE6mcJSAt4cVP8uky6sEa8ULd6b3ACRBvtgZtsecA9S/KtRjyE9CKr8nP+ogBNqJPaYlTz9RuwGedOd+8I9lYgsnRjfaHSByNMX08WEHtWqAWhSkAz/HO32ardS38cN97fckCgQtA8v7c77nBT7vcw4epgxyUQvMUxUhqmCVVhVfz8JXa5hyJxFrOtqgaVuQ1B5Y/EKxcyZT+JNHPtu3V1uc1awS/w16CEPstNBSFHax5MuT9UbY0mV2ZITP99EkM+vdomh82VHdnMo0i7Pz7XF45ychD4cteroO9gGqDDt9j7hd1rubBX1bfkPsd/APJlyeshusyTj+FqsUD/HDlvM9LRjY1HpU7i7yAlLQQ3851XKMLUPNFYu2r3bo8Wt/CCHtJvB4wYuH+7Wo3muudpU01ziJBxQrUWwPbUrG+7LvO1iEEVxB8l+8Vq0mU3Te7lJi1kGetm6xHNbtvQip5P2YUqvv+lLo/K8KoJDxsh63Y01JGwdmUDb8mnFlRx4J7hQJaoNEvz3cgnc4X8gDJD8sUOjGOPnbtz2QwTY+zj/5+FdLxWDCxNrHX5vvkVdJHcCqEfVvQTKfDMOUeKuhjI7GD7t3xRPfUxq19jjoLPe7aqn1Z1s=
 a38d44ba093bd1d1ecfd34119e94056030278b 0 iQIVAwUAVarUUyBXgaxoKi1yAQIfJw/+MG/0736F/9IvzgCTF6omIC+9kS8JH0n/JBGPhpbPAHK4xxjhOOz6m3Ia3c3HNoy+I6calwU6YV7k5dUzlyLhM0Z5oYpdrH+OBNxDEsD5SfhclfR63MK1kmgtD33izijsZ++6a+ZaVfyxpMTksKOktWSIDD63a5b/avb6nKY64KwJcbbeXPdelxvXV7TXYm0GvWc46BgvrHOJpYHCDaXorAn6BMq7EQF8sxdNK4GVMNMVk1njve0HOg3Kz8llPB/7QmddZXYLFGmWqICyUn1IsJDfePxzh8sOYVCbxAgitTJHJJmmH5gzVzw7t7ljtmxSJpcUGQJB2MphejmNFGfgvJPB9c6xOCfUqDjxN5m24V+UYesZntpfgs3lpfvE7785IpVnf6WfKG4PKty01ome/joHlDlrRTekKMlpiBapGMfv8EHvPBrOA+5yAHNfKsmcyCcjD1nvXYZ2/X9qY35AhdcBuNkyp55oPDOdtYIHfnOIxlYMKG1dusDx3Z4eveF0lQTzfRVoE5w+k9A2Ov3Zx0aiSkFFevJjrq5QBfs9dAiT8JYgBmWhaJzCtJm12lQirRMKR/br88Vwt/ry/UVY9cereMNvRYUGOGfC8CGGDCw4WDD+qWvyB3mmrXVuMlXxQRIZRJy5KazaQXsBWuIsx4kgGqC5Uo+yzpiQ1VMuCyI=
 aa1c313b05b1a85f8ffa1120d51579ddf6bf24 0 iQIVAwUAVbuouCBXgaxoKi1yAQL2ng//eI1w51F4YkDiUAhrZuc8RE/chEd2o4F6Jyu9laA03vbim598ntqGjX3+UkOyTQ/zGVeZfW2cNG8zkJjSLk138DHCYl2YPPD/yxqMOJp/a7U34+HrA0aE5Y2pcfx+FofZHRvRtt40UCngicjKivko8au7Ezayidpa/vQbc6dNvGrwwk4KMgOP2HYIfHgCirR5UmaWtNpzlLhf9E7JSNL5ZXij3nt6AgEPyn0OvmmOLyUARO/JTJ6vVyLEtwiXg7B3sF5RpmyFDhrkZ+MbFHgL4k/3y9Lb97WaZl8nXJIaNPOTPJqkApFY/56S12PKYK4js2OgU+QsX1XWvouAhEx6CC6Jk9EHhr6+9qxYFhBJw7RjbswUG6LvJy/kBe+Ei5UbYg9dATf3VxQ6Gqs19lebtzltERH2yNwaHyVeqqakPSonOaUyxGMRRosvNHyrTTor38j8d27KksgpocXzBPZcc1MlS3vJg2nIwZlc9EKM9z5R0J1KAi1Z/+xzBjiGRYg5EZY6ElAw30eCjGta7tXlBssJiKeHut7QTLxCZHQuX1tKxDDs1qlXlGCMbrFqo0EiF9hTssptRG3ZyLwMdzEjnh4ki6gzONZKDI8uayAS3N+CEtWcGUtiA9OwuiFXTwodmles/Mh14LEhiVZoDK3L9TPcY22o2qRuku/6wq6QKsg=
 a45e49a6bed023deb229102a8903234d18054d3 0 iQIVAwUAVeYa2SBXgaxoKi1yAQLWVA//Q7vU0YzngbxIbrTPvfFiNTJcT4bx9u1xMHRZf6QBIE3KtRHKTooJwH9lGR0HHM+8DWWZup3Vzo6JuWHMGoW0v5fzDyk2czwM9BgQQPfEmoJ/ZuBMevTkTZngjgHVwhP3tHFym8Rk9vVxyiZd35EcxP+4F817GCzD+K7XliIBqVggmv9YeQDXfEtvo7UZrMPPec79t8tzt2UadI3KC1jWUriTS1Fg1KxgXW6srD80D10bYyCkkdo/KfF6BGZ9SkF+U3b95cuqSmOfoyyQwUA3JbMXXOnIefnC7lqRC2QTC6mYDx5hIkBiwymXJBe8rpq/S94VVvPGfW6A5upyeCZISLEEnAz0GlykdpIy/NogzhmWpbAMOus05Xnen6xPdNig6c/M5ZleRxVobNrZSd7c5qI3aUUyfMKXlY1j9oiUTjSKH1IizwaI3aL/MM70eErBxXiLs2tpQvZeaVLn3kwCB5YhywO3LK0x+FNx4Gl90deAXMYibGNiLTq9grpB8fuLg9M90JBjFkeYkrSJ2yGYumYyP/WBA3mYEYGDLNstOby4riTU3WCqVl+eah6ss3l+gNDjLxiMtJZ/g0gQACaAvxQ9tYp5eeRMuLRTp79QQPxv97s8IyVwE/TlPlcSFlEXAzsBvqvsolQXRVi9AxA6M2davYabBYAgRf6rRfgujoU=
 a466b9f9792e3ad7ae3fc6c43c3ff2e136b718d 0 iQIVAwUAVg1oMSBXgaxoKi1yAQLPag/+Pv0+pR9b9Y5RflEcERUzVu92q+l/JEiP7PHP9pAZuXoQ0ikYBFo1Ygw8tkIG00dgEaLk/2b7E3OxaU9pjU3thoX//XpTcbkJtVhe7Bkjh9/S3dRpm2FWNL9n0qnywebziB45Xs8XzUwBZTYOkVRInYr/NzSo8KNbQH1B4u2g56veb8u/7GtEvBSGnMGVYKhVUZ3jxyDf371QkdafMOJPpogkZcVhXusvMZPDBYtTIzswyxBJ2jxHzjt8+EKs+FI3FxzvQ9Ze3M5Daa7xfiHI3sOgECO8GMVaJi0F49lttKx08KONw8xLlEof+cJ+qxLxQ42X5XOQglJ2/bv5ES5JiZYAti2XSXbZK96p4wexqL4hnaLVU/2iEUfqB9Sj6itEuhGOknPD9fQo1rZXYIS8CT5nGTNG4rEpLFN6VwWn1btIMNkEHw998zU7N3HAOk6adD6zGcntUfMBvQC3V4VK3o7hp8PGeySrWrOLcC/xLKM+XRonz46woJK5D8w8lCVYAxBWEGKAFtj9hv9R8Ye9gCW0Q8BvJ7MwGpn+7fLQ1BVZdV1LZQTSBUr5u8mNeDsRo4H2hITQRhUeElIwlMsUbbN078a4JPOUgPz1+Fi8oHRccBchN6I40QohL934zhcKXQ+NXYN8BgpCicPztSg8O8Y/qvhFP12Zu4tOH8P/dFY=
              b66e3ca0b90c3095ea28dfd39aa24247bebf5c20 0 iQIVAwUAViarTyBXgaxoKi1yAQLZgRAAh7c7ebn7kUWI5M/b/T6qHGjFrU5azkjamzy9IG+KIa2hZgSMxyEM7JJUFqKP4TiWa3sW03bjKGSM/SjjDSSyheX+JIVSPNyKrBwneYhPq45Ius8eiHziClkt0CSsl2d9xDRpI0JmHbN0Pf8nh7rnbL+231GDAOT6dP+2S8K1HGa/0BgEcL9gpYs4/2GyjL+hBSUjyrabzvwe48DCN5W0tEJbGFw5YEADxdfbVbNEuXL81tR4PFGiJxPW0QKRLDB74MWmiWC0gi2ZC/IhbNBZ2sLb6694d4Bx4PVwtiARh63HNXVMEaBrFu1S9NcMQyHvAOc6Zw4izF/PCeTcdEnPk8J1t5PTz09Lp0EAKxe7CWIViy350ke5eiaxO3ySrNMX6d83BOHLDqEFMSWm+ad+KEMT4CJrK4X/n/XMgEFAaU5nWlIRqrLRIeU2Ifc625T0Xh4BgTqXPpytQxhgV5b+Fi6duNk4cy+QnHT4ymxI6BPD9HvSQwc+O7h37qjvJVZmpQX6AP8O75Yza8ZbcYKRIIxZzOkwNpzE5A/vpvP5bCRn7AGcT3ORWmAYr/etr3vxUvt2fQz6U/R4S915V+AeWBdcp+uExu6VZ42M0vhhh0lyzx1VRJGVdV+LoxFKkaC42d0yT+O1QEhSB7WL1D3/a/iWubv6ieB/cvNMhFaK9DA=
 dd34f2e7272be9e3b2a5a83cd0d20be44293f4 0 iQIVAwUAVjZiKiBXgaxoKi1yAQKBWQ/+JcE37vprSOA5e0ezs/avC7leR6hTlXy9O5bpFnvMpbVMTUp+KfBE4HxTT0KKXKh9lGtNaQ+lAmHuy1OQE1hBKPIaCUd8/1gunGsXgRM3TJ9LwjFd4qFpOMxvOouc6kW5kmea7V9W2fg6aFNjjc/4/0J3HMOIjmf2fFz87xqR1xX8iezJ57A4pUPNViJlOWXRzfa56cI6VUe5qOMD0NRXcY+JyI5qW25Y/aL5D9loeKflpzd53Ue+Pu3qlhddJd3PVkaAiVDH+DYyRb8sKgwuiEsyaBO18IBgC8eDmTohEJt6707A+WNhwBJwp9aOUhHC7caaKRYhEKuDRQ3op++VqwuxbFRXx22XYR9bEzQIlpsv9GY2k8SShU5MZqUKIhk8vppFI6RaID5bmALnLLmjmXfSPYSJDzDuCP5UTQgI3PKPOATorVrqMdKzfb7FiwtcTvtHAXpOgLaY9P9XIePbnei6Rx9TfoHYDvzFWRqzSjl21xR+ZUrJtG2fx7XLbMjEAZJcnjP++GRvNbHBOi57aX0l2LO1peQqZVMULoIivaoLFP3i16RuXXQ/bvKyHmKjJzGrLc0QCa0yfrvV2m30RRMaYlOv7ToJfdfZLXvSAP0zbAuDaXdjGnq7gpfIlNE3xM+kQ75Akcf4V4fK1p061EGBQvQz6Ov3PkPiWL/bxrQ=
 aa5083cbebbe7575c88f3402ab377539b484897 0 iQIVAwUAVkEdCCBXgaxoKi1yAQKdWg//crTr5gsnHQppuD1p+PPn3/7SMsWJ7bgbuaXgERDLC0zWMfhM2oMmu/4jqXnpangdBVvb0SojejgzxoBo9FfRQiIoKt0vxmmn+S8CrEwb99rpP4M7lgyMAInKPMXQdYxkoDNwL70Afmog6eBtlxjYnu8nmUE/swu6JoVns+tF8UOvIKFYbuCcGujo2pUOQC0xBGiHeHSGRDJOlWmY2d7D/PkQtQE/u/d4QZt7enTHMiV44XVJ8+0U0f1ZQE7V+hNWf+IjwcZtL95dnQzUKs6tXMIln/OwO+eJ3d61BfLvmABvCwUC9IepPssNSFBUfGqBAP5wXOzFIPSYn00IWpmZtCnpUNL99X1IV3RP+p99gnEDTScQFPYt5B0q5I1nFdRh1p48BSF/kjPA7V++UfBwMXrrYLKhUR9BjmrRzYnyXJKwbH6iCNj5hsXUkVrBdBi/FnMczgsVILfFcIXUfnJD3E/dG+1lmuObg6dEynxiGChTuaR4KkLa5ZRkUcUl6fWlSRsqSNbGEEbdwcI+nTCZqJUlLSghumhs0Z89Hs1nltBd1ALX2VLJEHrKMrFQ8NfEBeCB6ENqMJi5qPlq354MCdGOZ9RvisX/HlxE4Q61BW0+EwnyXSch6LFSOS3axOocUazMoK1XiOTJSv/5bAsnwb0ztDWeUj9fZEJL+SWtgB8=
 d437a0f3355834a9485bbbeb30a52a052c98f19 0 iQIVAwUAVl5U9CBXgaxoKi1yAQLocg//a4YFz9UVSIEzVEJMUPJnN2dBvEXRpwpb5CdKPd428+18K6VWZd5Mc6xNNRV5AV/hCYylgqDplIvyOvwCj7uN8nEOrLUQQ0Pp37M5ZIX8ZVCK/wgchJ2ltabUG1NrZ7/JA84U79VGLAECMnD0Z9WvZDESpVXmdXfxrk1eCc3omRB0ofNghEx+xpYworfZsu8aap1GHQuBsjPv4VyUWGpMq/KA01PdxRTELmrJnfSyr0nPKwxlI5KsbA1GOe+Mk3tp5HJ42DZqLtKSGPirf6E+6lRJeB0H7EpotN4wD3yZDsw6AgRb2C/ay/3T3Oz7CN+45mwuujV9Cxx5zs1EeOgZcqgA/hXMcwlQyvQDMrWpO8ytSBm6MhOuFOTB3HnUxfsnfSocLJsbNwGWKceAzACcXSqapveVAz/7h+InFgl/8Qce28UJdnX5wro5gP6UWt+xrvc7vfmVGgI3oxbiOUrfglhkjmrxBjEiDQy4BWH7HWMZUVxnqPQRcxIE10+dv0KtM/PBkbUtnbGJ88opFBGkFweje5vQcZy/duuPEIufRkPr8EV47QjOxlvldEjlLq3+QUdJZEgCIFw1X0y7Pix4dsPFjwOmAyo4El1ePrdFzG3dXSVA3eHvMDRnYnNlue9wHvKhYbBle5xTOZBgGuMzhDVe+54JLql5JYr4WrI1pvA=
              ea389970c08449440587712117f178d33bab3f1e 0 iQIVAwUAVociGyBXgaxoKi1yAQJx9Q//TzMypcls5CQW3DM9xY1Q+RFeIw1LcDIev6NDBjUYxULb2WIK2qPw4Th5czF622SMd+XO/kiQeWYp9IW90MZOUVT1YGgUPKlKWMjkf0lZEPzprHjHq0+z/no1kBCBQg2uUOLsb6Y7zom4hFCyPsxXOk5nnxcFEK0VDbODa9zoKb/flyQ7rtzs+Z6BljIQ0TJAJsXs+6XgrW1XJ/f6nbeqsQyPklIBJuGKiaU1Pg8wQe6QqFaO1NYgM3hBETku6r3OTpUhu/2FTUZ7yDWGGzBqmifxzdHoj7/B+2qzRpII77PlZqoe6XF+UOObSFnhKvXKLjlGY5cy3SXBMbHkPcYtHua8wYR8LqO2bYYnsDd9qD0DJ+LlqH0ZMUkB2Cdk9q/cp1PGJWGlYYecHP87DLuWKwS+a6LhVI9TGkIUosVtLaIMsUUEz83RJFb4sSGOXtjk5DDznn9QW8ltXXMTdGQwFq1vmuiXATYenhszbvagrnbAnDyNFths4IhS1jG8237SB36nGmO3zQm5V7AMHfSrISB/8VPyY4Si7uvAV2kMWxuMhYuQbBwVx/KxbKrYjowuvJvCKaV101rWxvSeU2wDih20v+dnQKPveRNnO8AAK/ICflVVsISkd7hXcfk+SnhfxcPQTr+HQIJEW9wt5Q8WbgHk9wuR8kgXQEX6tCGpT/w=
 bdc8965720ca4061f8f8d806563cfc7cdb62e 0 iQIVAwUAVqBhFyBXgaxoKi1yAQLJpQ//S8kdgmVlS+CI0d2hQVGYWB/eK+tcntG+bZKLto4bvVy5d0ymlDL0x7VrJMOkwzkU1u/GaYo3L6CVEiM/JGCgB32bllrpx+KwQ0AyHswMZruo/6xrjDIYymLMEJ9yonXBZsG7pf2saYTHm3C5/ZIPkrDZSlssJHJDdeWqd75hUnx3nX8dZ4jIIxYDhtdB5/EmuEGOVlbeBHVpwfDXidSJUHJRwJvDqezUlN003sQdUvOHHtRqBrhsYEhHqPMOxDidAgCvjSfWZQKOTKaPE/gQo/BP3GU++Fg55jBz+SBXpdfQJI2Gd8FZfjLkhFa9vTTTcd10YCd4CZbYLpj/4R2xWj1U4oTVEFa6d+AA5Yyu8xG53XSCCPyzfagyuyfLqsaq5r1qDZO/Mh5KZCTvc9xSF5KXj57mKvzMDpiNeQcamGmsV4yXxymKJKGMQvbnzqp+ItIdbnfk38Nuac8rqNnGmFYwMIPa50680vSZT/NhrlPJ8FVTJlfHtSUZbdjPpsqw7BgjFWaVUdwgCKIGERiK7zfR0innj9rF5oVwT8EbKiaR1uVxOKnTwZzPCbdO1euNg/HutZLVQmugiLAv5Z38L3YZf5bH7zJdUydhiTI4mGn/mgncsKXoSarnnduhoYu9OsQZc9pndhxjAEuAslEIyBsLy81fR2HOhUzw5FGNgdY=
              2408645de650d8a29a6ce9e7dce601d8dd0d1474 0 iQIVAwUAVq/xFSBXgaxoKi1yAQLsxhAAg+E6uJCtZZOugrrFi9S6C20SRPBwHwmw22PC5z3Ufp9Vf3vqSL/+zmWI9d/yezIVcTXgM9rKCvq58sZvo4FuO2ngPx7bL9LMJ3qx0IyHUKjwa3AwrzjSzvVhNIrRoimD+lVBI/GLmoszpMICM+Nyg3D41fNJKs6YpnwwsHNJkjMwz0n2SHAShWAgIilyANNVnwnzHE68AIkB/gBkUGtrjf6xB9mXQxAv4GPco/234FAkX9xSWsM0Rx+JLLrSBXoHmIlmu9LPjC0AKn8/DDke+fj7bFaF7hdJBUYOtlYH6f7NIvyZSpw0FHl7jPxoRCtXzIV+1dZEbbIMIXzNtzPFVDYDfMhLqpTgthkZ9x0UaMaHecCUWYYBp8G/IyVS40GJodl8xnRiXUkFejbK/NDdR1f9iZS0dtiFu66cATMdb6d+MG+zW0nDKiQmBt6bwynysqn4g3SIGQFEPyEoRy0bXiefHrlkeHbdfc4zgoejx3ywcRDMGvUbpWs5C43EPu44irKXcqC695vAny3A7nZpt/XP5meDdOF67DNQPvhFdjPPbJBpSsUi2hUlZ+599wUfr3lNVzeEzHT7XApTOf6ysuGtHH3qcVHpFqQSRL1MI0f2xL13UadgTVWYrnHEis7f+ncwlWiR0ucpJB3+dQQh3NVGVo89MfbIZPkA8iil03U=
              b698abf971e7377d9b7ec7fc8c52df45255b0329 0 iQIVAwUAVrJ4YCBXgaxoKi1yAQJsKw/+JHSR0bIyarO4/VilFwsYxCprOnPxmUdS4qc4yjvpbf7Dqqr/OnOHJA29LrMoqWqsHgREepemjqiNindwNtlZec+KgmbF08ihSBBpls96UTTYTcytKRkkbrB+FhwB0iDl/o8RgGPniyG6M7gOp6p8pXQVRCOToIY1B/G0rtpkcU1N3GbiZntO5Fm/LPAVIE74VaDsamMopQ/wEB8qiERngX/M8SjO1ZSaVNW6KjRUsarLXQB9ziVJBolK/WnQsDwEeuWU2udpjBiOHnFC6h84uBpc8rLGhr419bKMJcjgl+0sl2zHGPY2edQYuJqVjVENzf4zzZA+xPgKw3GrSTpd37PEnGU/fufdJ0X+pp3kvmO1cV3TsvVMTCn7NvS6+w8SGdHdwKQQwelYI6vmJnjuOCATbafJiHMaOQ0GVYYk6PPoGrYcQ081x6dStCMaHIPOV1Wirwd2wq+SN9Ql8H6njftBf5Sa5tVWdW/zrhsltMsdZYZagZ/oFT3t83exL0rgZ96bZFs0j3HO3APELygIVuQ6ybPsFyToMDbURNDvr7ZqPKhQkkdHIUMqEez5ReuVgpbO9CWV/yWpB1/ZCpjNBZyDvw05kG2mOoC7AbHc8aLUS/8DetAmhwyb48LW4qjfUkO7RyxVSxqdnaBOMlsg1wsP2S+SlkZKsDHjcquZJ5U=
              d493d64757eb45ada99fcb3693e479a51b7782da 0 iQIVAwUAVtYt4SBXgaxoKi1yAQL6TQ/9FzYE/xOSC2LYqPdPjCXNjGuZdN1WMf/8fUMYT83NNOoLEBGx37C0bAxgD4/P03FwYMuP37IjIcX8vN6fWvtG9Oo0o2n/oR3SKjpsheh2zxhAFX3vXhFD4U18wCz/DnM0O1qGJwJ49kk/99WNgDWeW4n9dMzTFpcaeZBCu1REbZQS40Z+ArXTDCr60g5TLN1XR1WKEzQJvF71rvaE6P8d3GLoGobTIJMLi5UnMwGsnsv2/EIPrWHQiAY9ZEnYq6deU/4RMh9c7afZie9I+ycIA/qVH6vXNt3/a2BP3Frmv8IvKPzqwnoWmIUamew9lLf1joD5joBy8Yu+qMW0/s6DYUGQ4Slk9qIfn6wh4ySgT/7FJUMcayx9ONDq7920RjRc+XFpD8B3Zhj2mM+0g9At1FgX2w2Gkf957oz2nlgTVh9sdPvP6UvWzhqszPMpdG5Vt0oc5vuyobW333qSkufCxi5gmH7do1DIzErMcy8b6IpZUDeQ/dakKwLQpZVVPF15IrNa/zsOW55SrGrL8/ErM/mXNQBBAqvRsOLq2njFqK2JaoG6biH21DMjHVZFw2wBRoLQxbOppfz2/e3mNkNy9HjgJTW3+0iHWvRzMSjwRbk9BlbkmH6kG5163ElHq3Ft3uuQyZBL9I5SQxlHi9s/CV0YSTYthpWR3ChKIMoqBQ0=
              ae279d4a19e9683214cbd1fe8298cf0b50571432 0 iQIVAwUAVvqzViBXgaxoKi1yAQKUCxAAtctMD3ydbe+li3iYjhY5qT0wyHwPr9fcLqsQUJ4ZtD4sK3oxCRZFWFxNBk5bIIyiwusSEJPiPddoQ7NljSZlYDI0HR3R4vns55fmDwPG07Ykf7aSyqr+c2ppCGzn2/2ID476FNtzKqjF+LkVyadgI9vgZk5S4BgdSlfSRBL+1KtB1BlF5etIZnc5U9qs1uqzZJc06xyyF8HlrmMZkAvRUbsx/JzA5LgzZ2WzueaxZgYzYjDk0nPLgyPPBj0DVyWXnW/kdRNmKHNbaZ9aZlWmdPCEoq5iBm71d7Xoa61shmeuVZWvxHNqXdjVMHVeT61cRxjdfxTIkJwvlRGwpy7V17vTgzWFxw6QJpmr7kupRo3idsDydLDPHGUsxP3uMZFsp6+4rEe6qbafjNajkRyiw7kVGCxboOFN0rLVJPZwZGksEIkw58IHcPhZNT1bHHocWOA/uHJTAynfKsAdv/LDdGKcZWUCFOzlokw54xbPvdrBtEOnYNp15OY01IAJd2FCUki5WHvhELUggTjfank1Tc3/Rt1KrGOFhg80CWq6eMiuiWkHGvYq3fjNLbgjl3JJatUFoB+cX1ulDOGsLJEXQ4v5DNHgel0o2H395owNlStksSeW1UBVk0hUK/ADtVUYKAPEIFiboh1iDpEOl40JVnYdsGz3w5FLj2w+16/1vWs=
 eedf2c450aee58b1a90b0e826f47c5da64 0 iQIVAwUAVxLGMCBXgaxoKi1yAQLhIg/8DDX+sCz7LmqO47/FfTo+OqGR+bTTqpfK3WebitL0Z6hbXPj7s45jijqIFGqKgMPqS5oom1xeuGTPHdYA0NNoc/mxSCuNLfuXYolpNWPN71HeSDRV9SnhMThG5HSxI+P0Ye4rbsCHrVV+ib1rV81QE2kZ9aZsJd0HnGd512xJ+2ML7AXweM/4lcLmMthN+oi/dv1OGLzfckrcr/fEATCLZt55eO7idx11J1Fk4ptQ6dQ/bKznlD4hneyy1HMPsGxw+bCXrMF2C/nUiRLHdKgGqZ+cDq6loQRfFlQoIhfoEnWC424qbjH4rvHgkZHqC59Oi/ti9Hi75oq9Tb79yzlCY/fGsdrlJpEzrTQdHFMHUoO9CC+JYObXHRo3ALnC5350ZBKxlkdpmucrHTgcDabfhRlx9vDxP4RDopm2hAjk2LJH7bdxnGEyZYkTOZ3hXKnVpt2hUQb4jyzzC9Kl47TFpPKNVKI+NLqRRZAIdXXiy24KD7WzzE6L0NNK0/IeqKBENLL8I1PmDQ6XmYTQVhTuad1jjm2PZDyGiXmJFZO1O/NGecVTvVynKsDT6XhEvzyEtjXqD98rrhbeMHTcmNSwwJMDvm9ws0075sLQyq2EYFG6ECWFypdA/jfumTmxOTkMtuy/V1Gyq7YJ8YaksZ7fXNY9VuJFP72grmlXc6Dvpr4=
              f85de28eae32e7d3064b1a1321309071bbaaa069 0 iQIVAwUAVyZQaiBXgaxoKi1yAQJhCQ//WrRZ55k3VI/OgY+I/HvgFHOC0sbhe207Kedxvy00a3AtXM6wa5E95GNX04QxUfTWUf5ZHDfEgj0/mQywNrH1oJG47iPZSs+qXNLqtgAaXtrih6r4/ruUwFCRFxqK9mkhjG61SKicw3Q7uGva950g6ZUE5BsZ7XJWgoDcJzWKR+AH992G6H//Fhi4zFQAmB34++sm80wV6wMxVKA/qhQzetooTR2x9qrHpvCKMzKllleJe48yzPLJjQoaaVgXCDav0eIePFNw0WvVSldOEp/ADDdTGa65qsC1rO2BB1Cu5+frJ/vUoo0PwIgqgD6p2i41hfIKvkp6130TxmRVxUx+ma8gBYEpPIabV0flLU72gq8lMlGBBSnQ+fcZsfs/Ug0xRN0tzkEScmZFiDxRGk0y7IalXzv6irwOyC2fZCajXGJDzkROQXWMgy9eKkwuFhZBmPVYtrATSq3jHLVmJg5vfdeiVzA6NKxAgGm2z8AsRrijKK8WRqFYiH6xcWKG5u+FroPQdKa0nGCkPSTH3tvC6fAHTVm7JeXch5QE/LiS9Y575pM2PeIP+k+Fr1ugK0AEvYJAXa5UIIcdszPyI+TwPTtWaQ83X99qGAdmRWLvSYjqevOVr7F/fhO3XKFXRCcHA3EzVYnG7nWiVACYF3H2UgN4PWjStbx/Qhhdi9xAuks=
              a56296f55a5e1038ea5016dace2076b693c28a56 0 iQIVAwUAVyZarCBXgaxoKi1yAQL87g/8D7whM3e08HVGDHHEkVUgqLIfueVy1mx0AkRvelmZmwaocFNGpZTd3AjSwy6qXbRNZFXrWU85JJvQCi3PSo/8bK43kwqLJ4lv+Hv2zVTvz30vbLWTSndH3oVRu38lIA7b5K9J4y50pMCwjKLG9iyp+aQG4RBz76fJMlhXy0gu38A8JZVKEeAnQCbtzxKXBzsC8k0/ku/bEQEoo9D4AAGlVTbl5AsHMp3Z6NWu7kEHAX/52/VKU2I0LxYqRxoL1tjTVGkAQfkOHz1gOhLXUgGSYmA9Fb265AYj9cnGWCfyNonlE0Rrk2kAsrjBTGiLyb8WvK/TZmRo4ZpNukzenS9UuAOKxA22Kf9+oN9kKBu1HnwqusYDH9pto1WInCZKV1al7DMBXbGFcnyTXk2xuiTGhVRG5LzCO2QMByBLXiYl77WqqJnzxK3v5lAc/immJl5qa3ATUlTnVBjAs+6cbsbCoY6sjXCT0ClndA9+iZZ1TjPnmLrSeFh5AoE8WHmnFV6oqGN4caX6wiIW5vO+x5Q2ruSsDrwXosXIYzm+0KYKRq9O+MaTwR44Dvq3/RyeIu/cif/Nc7B8bR5Kf7OiRf2T5u97MYAomwGcQfXqgUfm6y7D3Yg+IdAdAJKitxhRPsqqdxIuteXMvOvwukXNDiWP1zsKoYLI37EcwzvbGLUlZvg=
              aaabed77791a75968a12b8c43ad263631a23ee81 0 iQIVAwUAVzpH4CBXgaxoKi1yAQLm5A/9GUYv9CeIepjcdWSBAtNhCBJcqgk2cBcV0XaeQomfxqYWfbW2fze6eE+TrXPKTX1ajycgqquMyo3asQolhHXwasv8+5CQxowjGfyVg7N/kyyjgmJljI+rCi74VfnsEhvG/J4GNr8JLVQmSICfALqQjw7XN8doKthYhwOfIY2vY419613v4oeBQXSsItKC/tfKw9lYvlk4qJKDffJQFyAekgv43ovWqHNkl4LaR6ubtjOsxCnxHfr7OtpX3muM9MLT/obBax5I3EsmiDTQBOjbvI6TcLczs5tVCnTa1opQsPUcEmdA4WpUEiTnLl9lk9le/BIImfYfEP33oVYmubRlKhJYnUiu89ao9L+48FBoqCY88HqbjQI1GO6icfRJN/+NLVeE9wubltbWFETH6e2Q+Ex4+lkul1tQMLPcPt10suMHnEo3/FcOTPt6/DKeMpsYgckHSJq5KzTg632xifyySmb9qkpdGGpY9lRal6FHw3rAhRBqucMgxso4BwC51h04RImtCUQPoA3wpb4BvCHba/thpsUFnHefOvsu3ei4JyHXZK84LPwOj31PcucNFdGDTW6jvKrF1vVUIVS9uMJkJXPu0V4i/oEQSUKifJZivROlpvj1eHy3KeMtjq2kjGyXY2KdzxpT8wX/oYJhCtm1XWMui5f24XBjE6xOcjjm8k4=
              a9764ab80e11bcf6a37255db7dd079011f767c6c 0 iQIVAwUAV09KHyBXgaxoKi1yAQJBWg/+OywRrqU+zvnL1tHJ95PgatsF7S4ZAHZFR098+oCjUDtKpvnm71o2TKiY4D5cckyD2KNwLWg/qW6V+5+2EYU0Y/ViwPVcngib/ZeJP+Nr44TK3YZMRmfFuUEEzA7sZ2r2Gm8eswv//W79I0hXJeFd/o6FgLnn7AbOjcOn3IhWdGAP6jUHv9zyJigQv6K9wgyvAnK1RQE+2CgMcoyeqao/zs23IPXI6XUHOwfrQ7XrQ83+ciMqN7XNRx+TKsUQoYeUew4AanoDSMPAQ4kIudsP5tOgKeLRPmHX9zg6Y5S1nTpLRNdyAxuNuyZtkQxDYcG5Hft/SIx27tZUo3gywHL2U+9RYD2nvXqaWzT3sYB2sPBOiq7kjHRgvothkXemAFsbq2nKFrN0PRua9WG4l3ny0xYmDFPlJ/s0E9XhmQaqy+uXtVbA2XdLEvE6pQ0YWbHEKMniW26w6LJkx4IV6RX/7Kpq7byw/bW65tu/BzgISKau5FYLY4CqZJH7f8QBg3XWpzB91AR494tdsD+ugM45wrY/6awGQx9CY5SAzGqTyFuSFQxgB2rBurb01seZPf8nqG8V13UYXfX/O3/WMOBMr7U/RVqmAA0ZMYOyEwfVUmHqrFjkxpXX+JdNKRiA1GJp5sdRpCxSeXdQ/Ni6AAGZV2IyRb4G4Y++1vP4yPBalas=
 a5d605b8683a292bb89aea11f37a81b06ac016 0 iQIVAwUAV3bOsSBXgaxoKi1yAQLiDg//fxmcNpTUedsXqEwNdGFJsJ2E25OANgyv1saZHNfbYFWXIR8g4nyjNaj2SjtXF0wzOq5aHlMWXjMZPOT6pQBdTnOYDdgv+O8DGpgHs5x/f+uuxtpVkdxR6uRP0/ImlTEtDix8VQiN3nTu5A0N3C7E2y+D1JIIyTp6vyjzxvGQTY0MD/qgB55Dn6khx8c3phDtMkzmVEwL4ItJxVRVNw1m+2FOXHu++hJEruJdeMV0CKOV6LVbXHho+yt3jQDKhlIgJ65EPLKrf+yRalQtSWpu7y/vUMcEUde9XeQ5x05ebCiI4MkJ0ULQro/Bdx9vBHkAstUC7D+L5y45ZnhHjOwxz9c3GQMZQt1HuyORqbBhf9hvOkUQ2GhlDHc5U04nBe0VhEoCw9ra54n+AgUyqWr4CWimSW6pMTdquCzAAbcJWgdNMwDHrMalCYHhJksKFARKq3uSTR1Noz7sOCSIEQvOozawKSQfOwGxn/5bNepKh4uIRelC1uEDoqculqCLgAruzcMNIMndNVYaJ09IohJzA9jVApa+SZVPAeREg71lnS3d8jaWh1Lu5JFlAAKQeKGVJmNm40Y3HBjtHQDrI67TT59oDAhjo420Wf9VFCaj2k0weYBLWSeJhfUZ5x3PVpAHUvP/rnHPwNYyY0wVoQEvM/bnQdcpICmKhqcK+vKjDrM=
 bb4f9d3a47a6e83c2b414d58811ed38f503c2 0 iQIVAwUAV42tNyBXgaxoKi1yAQI/Iw//V0NtxpVD4sClotAwffBVW42Uv+SG+07CJoOuFYnmHZv/plOzXuuJlmm95L00/qyRCCTUyAGxK/eP5cAKP2V99ln6rNhh8gpgvmZlnYjU3gqFv8tCQ+fkwgRiWmgKjRL6/bK9FY5cO7ATLVu3kCkFd8CEgzlAaUqBfkNFxZxLDLvKqRlhXxVXhKjvkKg5DZ6eJqRQY7w3UqqR+sF1rMLtVyt490Wqv7YQKwcvY7MEKTyH4twGLx/RhBpBi+GccVKvWC011ffjSjxqAfQqrrSVt0Ld1Khj2/p1bDDYpTgtdDgCzclSXWEQpmSdFRBF5wYs/pDMUreI/E6mlWkB4hfZZk1NBRPRWYikXwnhU3ziubCGesZDyBYLrK1vT+tf6giseo22YQmDnOftbS999Pcn04cyCafeFuOjkubYaINB25T20GS5Wb4a0nHPRAOOVxzk/m/arwYgF0ZZZDDvJ48TRMDf3XOc1jc5qZ7AN/OQKbvh2B08vObnnPm3lmBY1qOnhwzJxpNiq+Z/ypokGXQkGBfKUo7rWHJy5iXLb3Biv9AhxY9d5pSTjBmTAYJEic3q03ztzlnfMyi+C13+YxFAbSSNGBP8Hejkkz0NvmB1TBuCKpnZA8spxY5rhZ/zMx+cCw8hQvWHHDUURps7SQvZEfrJSCGJFPDHL3vbfK+LNwI=
 f84e68dbb9bd026f0f3a974ce4bdb93686 0 iQIcBAABCAAGBQJXn3rFAAoJELnJ3IJKpb3VmZoQAK0cdOfi/OURglnN0vYYGwdvSXTPpZauPEYEpwML3dW1j6HRnl5L+H8D8vlYzahK95X4+NNBhqtyyB6wmIVI0NkYfXfd6ACntJE/EnTdLIHIP2NAAoVsggIjiNr26ubRegaD5ya63Ofxz+Yq5iRsUUfHet7o+CyFhExyzdu+Vcz1/E9GztxNfTDVpC/mf+RMLwQTfHOhoTVbaamLCmGAIjw39w72X+vRMJoYNF44te6PvsfI67+6uuC0+9DjMnp5eL/hquSQ1qfks71rnWwxuiPcUDZloIueowVmt0z0sO4loSP1nZ5IP/6ZOoAzSjspqsxeay9sKP0kzSYLGsmCi29otyVSnXiKtyMCW5z5iM6k8XQcMi5mWy9RcpqlNYD7RUTn3g0+a8u7F6UEtske3/qoweJLPhtTmBNOfDNw4JXwOBSZea0QnIIjCeCc4ZGqfojPpbvcA4rkRpxI23YoMrT2v/kp4wgwrqK9fi8ctt8WbXpmGoAQDXWj2bWcuzj94HsAhLduFKv6sxoDz871hqjmjjnjQSU7TSNNnVzdzwqYkMB+BvhcNYxk6lcx3Aif3AayGdrWDubtU/ZRNoLzBwe6gm0udRMXBj4D/60GD6TIkYeL7HjJwfBb6Bf7qvQ6y7g0zbYG9uwBmMeduU7XchErGqQGSEyyJH3DG9OLaFOj
              ccd436f7db6d5d7b9af89715179b911d031d44f1 0 iQIVAwUAV8h7F0emf/qjRqrOAQjmdhAAgYhom8fzL/YHeVLddm71ZB+pKDviKASKGSrBHY4D5Szrh/pYTedmG9IptYue5vzXpspHAaGvZN5xkwrz1/5nmnCsLA8DFaYT9qCkize6EYzxSBtA/W1S9Mv5tObinr1EX9rCSyI4HEJYE8i1IQM5h07SqUsMKDoasd4e29t6gRWg5pfOYq1kc2MTck35W9ff1Fii8S28dqbO3cLU6g5K0pT0JLCZIq7hyTNQdxHAYfebxkVl7PZrZR383IrnyotXVKFFc44qinv94T50uR4yUNYPQ8Gu0TgoGQQjBjk1Lrxot2xpgPQAy8vx+EOJgpg/yNZnYkmJZMxjDkTGVrwvXtOXZzmy2jti7PniET9hUBCU7aNHnoJJLzIf+Vb1CIRP0ypJl8GYCZx6HIYwOQH6EtcaeUqq3r+WXWv74ijIE7OApotmutM9buTvdOLdZddBzFPIjykc6cXO+W4E0kl6u9/OHtaZ3Nynh0ejBRafRWAVw2yU3T9SgQyICsmYWJCThkj14WqCJr2b7jfGlg9MkQOUG6/3f4xz2R3SgyUD8KiGsq/vdBE53zh0YA9gppLoum6AY+z61G1NhVGlrtps90txZBehuARUUz2dJC0pBMRy8XFwXMewDSIe6ATg25pHZsxHfhcalBpJncBl8pORs7oQl+GKBVxlnV4jm1pCzLU=
 e68974eb5c63ccb03f794d8b57339a80c4 0 iQIcBAABAgAGBQJX8AfCAAoJELnJ3IJKpb3VnNAP/3umS8tohcZTr4m6DJm9u4XGr2m3FWQmjTEfimGpsOuBC8oCgsq0eAlORYcV68zDax+vQHQu3pqfPXaX+y4ZFDuz0ForNRiPJn+Q+tj1+NrOT1e8h4gH0nSK4rDxEGaa6x01fyC/xQMqN6iNfzbLLB7+WadZlyBRbHaUeZFDlPxPDf1rjDpu1vqwtOrVzSxMasRGEceiUegwsFdFMAefCq0ya/pKe9oV+GgGfR4qNrP7BfpOBcN/Po/ctkFCbLOhHbu6M7HpBSiD57BUy5lfhQQtSjzCKEVTyrWEH0ApjjXKuJzLSyq7xsHKQSOPMgGQprGehyzdCETlZOdauGrC0t9vBCr7kXEhXtycqxBC03vknA2eNeV610VX+HgO9VpCVZWHtENiArhALCcpoEsJvT29xCBYpSii/wnTpYJFT9yW8tjQCxH0zrmEZJvO1/nMINEBQFScB/nzUELn9asnghNf6vMpSGy0fSM27j87VAXCzJ5lqa6WCL/RrKgvYflow/m5AzUfMQhpqpH1vmh4ba1zZ4123lgnW4pNZDV9kmwXrEagGbWe1rnmsMzHugsECiYQyIngjWzHfpHgyEr49Uc5bMM1MlTypeHYYL4kV1jJ8Ou0SC4aV+49p8Onmb2NlVY7JKV7hqDCuZPI164YXMxhPNst4XK0/ENhoOE+8iB6
 c415874f6ac653efc1099dec9c9150e90f 0 iQIVAwUAWAZ3okemf/qjRqrOAQj89xAAw/6QZ07yqvH+aZHeGQfgJ/X1Nze/hSMzkqbwGkuUOWD5ztN8+c39EXCn8JlqyLUPD7uGzhTV0299k5fGRihLIseXr0hy/cvVW16uqfeKJ/4/qL9zLS3rwSAgWbaHd1s6UQZVfGCb8V6oC1dkJxfrE9h6kugBqV97wStIRxmCpMDjsFv/zdNwsv6eEdxbiMilLn2/IbWXFOVKJzzv9iEY5Pu5McFR+nnrMyUZQhyGtVPLSkoEPsOysorfCZaVLJ6MnVaJunp9XEv94Pqx9+k+shsQvJHWkc0Nnb6uDHZYkLR5v2AbFsbJ9jDHsdr9A7qeQTiZay7PGI0uPoIrkmLya3cYbU1ADhwloAeQ/3gZLaJaKEjrXcFSsz7AZ9yq74rTwiPulF8uqZxJUodk2m/zy83HBrxxp/vgxWJ5JP2WXPtB8qKY+05umAt4rQS+fd2H/xOu2V2d5Mq1WmgknLBLC0ItaNaf91sSHtgEy22GtcvWQE7S6VWU1PoSYmOLITdJKAsmb7Eq+yKDW9nt0lOpUu2wUhBGctlgXgcWOmJP6gL6edIg66czAkVBp/fpKNl8Z/A0hhpuH7nW7GW/mzLVQnc+JW4wqUVkwlur3NRfvSt5ZyTY/SaR++nRf62h7PHIjU+f0kWQRdCcEQ0X38b8iAjeXcsOW8NCOPpm0zcz3i8=
              eab27446995210c334c3d06f1a659e3b9b5da769 0 iQIcBAABCAAGBQJYGNsXAAoJELnJ3IJKpb3Vf30QAK/dq5vEHEkufLGiYxxkvIyiRaswS+8jamXeHMQrdK8CuokcQYhEv9xiUI6FMIoX4Zc0xfoFCBc+X4qE+Ed9SFYWgQkDs/roJq1C1mTYA+KANMqJkDt00QZq536snFQvjCXAA5fwR/DpgGOOuGMRfvbjh7x8mPyVoPr4HDQCGFXnTYdn193HpTOqUsipzIV5OJqQ9p0sfJjwKP4ZfD0tqqdjTkNwMyJuwuRaReXFvGGCjH2PqkZE/FwQG0NJJjt0xaMUmv5U5tXHC9tEVobVV/qEslqfbH2v1YPF5d8Jmdn7F76FU5J0nTd+3rIVjYGYSt01cR6wtGnzvr/7kw9kbChw4wYhXxnmIALSd48FpA1qWjlPcAdHfUUwObxOxfqmlnBGtAQFK+p5VXCsxDZEIT9MSxscfCjyDQZpkY5S5B3PFIRg6V9bdl5a4rEt27aucuKTHj1Ok2vip4WfaIKk28YMjjzuOQRbr6Pp7mJcCC1/ERHUJdLsaQP+dy18z6XbDjX3O2JDRNYbCBexQyV/Kfrt5EOS5fXiByQUHv+PyR+9Ju6QWkkcFBfgsxq25kFl+eos4V9lxPOY5jDpw2BWu9TyHtTWkjL/YxDUGwUO9WA/WzrcT4skr9FYrFV/oEgi8MkwydC0cFICDfd6tr9upqkkr1W025Im1UBXXJ89bTVj
              b3b1ae98f6a0e14c1e1ba806a6c18e193b6dae5c 0 iQIVAwUAWECEaEemf/qjRqrOAQjuZw/+IWJKnKOsaUMcB9ly3Fo/eskqDL6A0j69IXTJDeBDGMoyGbQU/gZyX2yc6Sw3EhwTSCXu5vKpzg3a6e8MNrC1iHqli4wJ/jPY7XtmiqTYDixdsBLNk46VfOi73ooFe08wVDSNB65xpZsrtPDSioNmQ2kSJwSHb71UlauS4xGkM74vuDpWvX5OZRSfBqMh6NjG5RwBBnS8mzA0SW2dCI2jSc5SCGIzIZpzM0xUN21xzq0YQbrk9qEsmi7ks0eowdhUjeET2wSWwhOK4jS4IfMyRO7KueUB05yHs4mChj9kNFNWtSzXKwKBQbZzwO/1Y7IJjU+AsbWkiUu+6ipqBPQWzS28gCwGOrv5BcIJS+tzsvLUKWgcixyfy5UAqJ32gCdzKC54FUpT2zL6Ad0vXGM6WkpZA7yworN4RCFPexXbi0x2GSTLG8PyIoZ4Iwgtj5NtsEDHrz0380FxgnKUIC3ny2SVuPlyD+9wepD3QYcxdRk1BIzcFT9ZxNlgil3IXRVPwVejvQ/zr6/ILdhBnZ8ojjvVCy3b86B1OhZj/ZByYo5QaykVqWl0V9vJOZlZfvOpm2HiDhm/2uNrVWxG4O6EwhnekAdaJYmeLq1YbhIfGA6KVOaB9Yi5A5BxK9QGXBZ6sLj+dIUD3QR47r9yAqVQE8Gr/Oh6oQXBQqOQv7WzBBs=
              e69874dc1f4e142746ff3df91e678a09c6fc208c 0 iQIVAwUAWG0oGUemf/qjRqrOAQh3uhAAu4TN7jkkgH7Hxn8S1cB6Ru0x8MQutzzzpjShhsE/G7nzCxsZ5eWdJ5ItwXmKhunb7T0og54CGcTxfmdPtCI7AhhHh9/TM2Hv1EBcsXCiwjG8E+P6X1UJkijgTGjNWuCvEDOsQAvgywslECBNnXp2QA5I5UdCMeqDdTAb8ujvbD8I4pxUx1xXKY18DgQGJh13mRlfkEVnPxUi2n8emnwPLjbVVkVISkMFUkaOl8a4fOeZC1xzDpoQocoH2Q8DYa9RCPPSHHSYPNMWGCdNGN2CoAurcHWWvc7jNU28/tBhTazfFv8LYh63lLQ8SIIPZHJAOxo45ufMspzUfNgoD6y3vlF5aW7DpdxwYHnueh7S1Fxgtd9cOnxmxQsgiF4LK0a+VXOi/Tli/fivZHDRCGHJvJgsMQm7pzkay9sGohes6jAnsOv2E8DwFC71FO/btrAp07IRFxH9WhUeMsXLMS9oBlubMxMM58M+xzSKApK6bz2MkLsx9cewmfmfbJnRIK1xDv+J+77pWWNGlxCCjl1WU+aA3M7G8HzwAqjL75ASOWtBrJlFXvlLgzobwwetg6cm44Rv1P39i3rDySZvi4BDlOQHWFupgMKiXnZ1PeL7eBDs/aawrE0V2ysNkf9An+XJZkos2JSLPWcoNigfXNUu5c1AqsERvHA246XJzqvCEK8=
              a1dd2c0c479e0550040542e392e87bc91262517e 0 iQIcBAABCAAGBQJYgBBEAAoJELnJ3IJKpb3VJosP/10rr3onsVbL8E+ri1Q0TJc8uhqIsBVyD/vS1MJtbxRaAdIV92o13YOent0o5ASFF/0yzVKlOWPQRjsYYbYY967k1TruDaWxJAnpeFgMni2Afl/qyWrW4AY2xegZNZCfMmwJA+uSJDdAn+jPV40XbuCZ+OgyZo5S05dfclHFxdc8rPKeUsJtvs5PMmCL3iQl1sulp1ASjuhRtFWZgSFsC6rb2Y7evD66ikL93+0/BPEB4SVX17vB/XEzdmh4ntyt4+d1XAznLHS33IU8UHbTkUmLy+82WnNH7HBB2V7gO47m/HhvaYjEfeW0bqMzN3aOUf30Vy/wB4HHsvkBGDgL5PYVHRRovGcAuCmnYbOkawqbRewW5oDs7UT3HbShNpxCxfsYpo7deHr11zWA3ooWCSlIRRREU4BfwVmn+Ds1hT5HM28Q6zr6GQZegDUbiT9i1zU0EpyfTpH7gc6NTVQrO1z1p70NBnQMqXcHjWJwjSwLER2Qify9MjrGXTL6ofD5zVZKobeRmq94mf3lDq26H7coraM9X5h9xa49VgAcRHzn/WQ6wcFCKDQr6FT67hTUOlF7Jriv8/5h/ziSZr10fCObKeKWN8Skur29VIAHHY4NuUqbM55WohD+jZ2O3d4tze1eWm5MDgWD8RlrfYhQ+cLOwH65AOtts0LNZwlvJuC7
              e1526da1e6d84e03146151c9b6e6950fe9a83d7d 0 iQIVAwUAWJIKpUemf/qjRqrOAQjjThAAvl1K/GZBrkanwEPXomewHkWKTEy1s5d5oWmPPGrSb9G4LM/3/abSbQ7fnzkS6IWi4Ao0za68w/MohaVGKoMAslRbelaTqlus0wE3zxb2yQ/j2NeZzFnFEuR/vbUug7uzH+onko2jXrt7VcPNXLOa1/g5CWwaf/YPfJO4zv+atlzBHvuFcQCkdbcOJkccCnBUoR7y0PJoBJX6K7wJQ+hWLdcY4nVaxkGPRmsZJo9qogXZMw1CwJVjofxRI0S/5vMtEqh8srYsg7qlTNv8eYnwdpfuunn2mI7Khx10Tz85PZDnr3SGRiFvdfmT30pI7jL3bhOHALkaoy2VevteJjIyMxANTvjIUBNQUi+7Kj3VIKmkL9NAMAQBbshiQL1wTrXdqOeC8Nm1BfCQEox2yiC6pDFbXVbguwJZ5VKFizTTK6f6BdNYKTVx8lNEdjAsWH8ojgGWwGXBbTkClULHezJ/sODaZzK/+M/IzbGmlF27jJYpdJX8fUoybZNw9lXwIfQQWHmQHEOJYCljD9G1tvYY70+xAFexgBX5Ib48UK4DRITVNecyQZL7bLTzGcM0TAE0EtD4M42wawsYP3Cva9UxShFLICQdPoa4Wmfs6uLbXG1DDLol/j7b6bL+6W8E3AlW+aAPc8GZm51/w3VlYqqciWTc12OJpu8FiD0pZ/iBw+E=
 b624d27e3917d978af56d6ad59331e0464a 0 iQIcBAABCAAGBQJYuMSwAAoJELnJ3IJKpb3VL3YP/iKWY3+K3cLUBD3Ne5MhfS7N3t6rlk9YD4kmU8JnVeV1oAfg36VCylpbJLBnmQdvC8AfBJOkXi6DHp9RKXXmlsOeoppdWYGX5RMOzuwuGPBii6cA6KFd+WBpBJlRtklz61qGCAtv4q8V1mga0yucihghzt4lD/PPz7mk6yUBL8s3rK+bIHGdEhnK2dfnn/U2G0K/vGgsYZESORISuBclCrrc7M3/v1D+FBMCEYX9FXYU4PhYkKXK1mSqzCB7oENu/WP4ijl1nRnEIyzBV9pKO4ylnXTpbZAr/e4PofzjzPXb0zume1191C3wvgJ4eDautGide/Pxls5s6fJRaIowf5XVYQ5srX/NC9N3K77Hy01t5u8nwcyAhjmajZYuB9j37nmiwFawqS/y2eHovrUjkGdelV8OM7/iAexPRC8i2NcGk0m6XuzWy1Dxr8453VD8Hh3tTeafd6v5uHXSLjwogpu/th5rk/i9/5GBzc1MyJgRTwBhVHi/yFxfyakrSU7HT2cwX/Lb5KgWccogqfvrFYQABIBanxLIeZxTv8OIjC75EYknbxYtvvgb35ZdJytwrTHSZN0S7Ua2dHx2KUnHB6thbLu/v9fYrCgFF76DK4Ogd22Cbvv6NqRoglG26d0bqdwz/l1n3o416YjupteW8LMxHzuwiJy69WP1yi10eNDq
              ed5b25874d998ababb181a939dd37a16ea644435 0 iQIcBAABCAAGBQJY4r/gAAoJELnJ3IJKpb3VtwYP/RuTmo252ExXQk/n5zGJZvZQnI86vO1+yGuyOlGFFBwf1v3sOLW1HD7fxF6/GdT8CSQrRqtC17Ya3qtayfY/0AEiSuH2bklBXSB1H5wPyguS5iLqyilCJY0SkHYBIDhJ0xftuIjsa805wdMm3OdclnTOkYT+K1WL8Ylbx/Ni2Lsx1rPpYdcQ/HlTkr5ca1ZbNOOSxSNI4+ilGlKbdSYeEsmqB2sDEiSaDEoxGGoSgzAE9+5Q2FfCGXV0bq4vfmEPoT9lhB4kANE+gcFUvsJTu8Z7EdF8y3CJLiy8+KHO/VLKTGJ1pMperbig9nAXl1AOt+izBFGJGTolbR/ShkkDWB/QVcqIF5CysAWMgnHAx7HjnMDBOANcKzhMMfOi3GUvOCNNIqIIoJHKRHaRk0YbMdt7z2mKpTrRQ9Zadz764jXOqqrPgQFM3jkBHzAvZz9yShrHGh42Y+iReAF9pAN0xPjyZ5Y2qp+DSl0bIQqrAet6Zd3QuoJtXczAeRrAvgn7O9MyLnMyE5s7xxI7o8M7zfWtChLF8ytJUzmRo3iVJNOJH+Zls9N30PGw6vubQAnB5ieaVTv8lnNpcAnEQD/i0tmRSxzyyqoOQbnItIPKFOsaYW+eX9sgJmObU3yDc5k3cs+yAFD2CM/uiUsLcTKyxPNcP1JHBYpwhOjIGczSHVS1
 eaf9539499a1b8be259ffe7ada787d07857f80 0 iQIcBAABCAAGBQJY9iz9AAoJELnJ3IJKpb3VYqEQAJNkB09sXgYRLA4kGQv3p4v02q9WZ1lHkAhOlNwIh7Zp+pGvT33nHZffByA0v+xtJNV9TNMIFFjkCg3jl5Z42CCe33ZlezGBAzXU+70QPvOR0ojlYk+FdMfeSyCBzWYokIpImwNmwNGKVrUAfywdikCsUC2aRjKg4Mn7GnqWl9WrBG6JEOOUamdx8qV2f6g/utRiqj4YQ86P0y4K3yakwc1LMM+vRfrwvsf1+DZ9t7QRENNKQ6gRnUdfryqSFIWn1VkBVMwIN5W3yIrTMfgH1wAZxbnYHrN5qDK7mcbP7bOA3XWJuEC+3QRnheRFd/21O1dMFuYjaKApXPHRlTGRMOaz2eydbfBopUS1BtfYEh4/B/1yJb9/HDw6LiAjea7ACHiaNec83z643005AvtUuWhjX3QTPkYlQzWaosanGy1IOGtXCPp1L0A+9gUpqyqycfPjQCbST5KRzYSZn3Ngmed5Bb6jsgvg5e5y0En/SQgK/pTKnxemAmFFVvIIrrWGRKj0AD0IFEHEepmwprPRs97EZPoBPFAGmVRuASBeIhFQxSDIXV0ebHJoUmz5w1rTy7U3Eq0ff6nW14kjWOUplatXz5LpWJ3VkZKrI+4gelto5xpTI6gJl2nmezhXQIlInk17cPuxmiHjeMdlOHZRh/zICLhQNL5fGne0ZL+qlrXY
 e788321cc4ae9975b7f0c54c849f36d82182b 0 iQIVAwUAWPZuQkemf/qjRqrOAQjFlg/9HXEegJMv8FP+uILPoaiA2UCiqWUL2MVJ0K1cvafkwUq+Iwir8sTe4VJ1v6V+ZRiOuzs4HMnoGJrIks4vHRbAxJ3J6xCfvrsbHdl59grv54vuoL5FlZvkdIe8L7/ovKrUmNwPWZX2v+ffFPrsEBeVlVrXpp4wOPhDxCKTmjYVOp87YqXfJsud7EQFPqpV4jX8DEDtJWT95OE9x0srBg0HpSE95d/BM4TuXTVNI8fV41YEqearKeFIhLxu37HxUmGmkAALCi8RJmm4hVpUHgk3tAVzImI8DglUqnC6VEfaYb+PKzIqHelhb66JO/48qN2S/JXihpNHAVUBysBT0b1xEnc6eNsF2fQEB+bEcf8IGj7/ILee1cmwPtoK2OXR2+xWWWjlu2keVcKeI0yAajJw/dP21yvVzVq0ypst7iD+EGHLJWJSmZscbyH5ICr+TJ5yQvIGZJtfsAdAUUTM2xpqSDW4mT5kYyg75URbQ3AKI7lOhJBmkkGQErE4zIQMkaAqcWziVF20xiRWfJoFxT2fK5weaRGIjELH49NLlyvZxYc4LlRo9lIdC7l/6lYDdTx15VuEj1zx/91y/d7OtPm+KCA2Bbdqth8m/fMD8trfQ6jSG/wgsvjZ+S0eoXa92qIR/igsCI+6EwP7duuzL2iyKOPXupQVNN10PKI7EuKv4Lk=
              bb96d4a497432722623ae60d9bc734a1e360179e 0 iQIVAwUAWQkDfEemf/qjRqrOAQierQ/7BuQ0IW0T0cglgqIgkLuYLx2VXJCTEtRNCWmrH2UMK7fAdpAhN0xf+xedv56zYHrlyHpbskDbWvsKIHJdw/4bQitXaIFTyuMMtSR5vXy4Nly34O/Xs2uGb3Y5qwdubeK2nZr4lSPgiRHb/zI/B1Oy8GX830ljmIOY7B0nUWy4DrXcy/M41SnAMLFyD1K6T/8tkv7M4Fai7dQoF9EmIIkShVPktI3lqp3m7infZ4XnJqcqUB0NSfQZwZaUaoalOdCvEIe3ab5ewgl/CuvlDI4oqMQGjXCtNLbtiZSwo6hvudO6ewT+Zn/VdabkZyRtXUxu56ajjd6h22nU1+vknqDzo5tzw6oh1Ubzf8tzyv3Gmmr+tlOjzfK7tXXnT3vR9aEGli0qri0DzOpsDSY0pDC7EsS4LINPoNdsGQrGQdoX++AISROlNjvyuo4Vrp26tPHCSupkKOXuZaiozycAa2Q+aI1EvkPZSXe8SAXKDVtFn05ZB58YVkFzZKAYAxkE/ven59zb4aIbOgR12tZbJoZZsVHrlf/TcDtiXVfIMEMsCtJ1tPgD1rAsEURWRxK3mJ0Ev6KTHgNz4PeBhq1gIP/Y665aX2+cCjc4+vApPUienh5aOr1bQFpIDyYZsafHGMUFNCwRh8bX98oTGa0hjqz4ypwXE4Wztjdc+48UiHARp/Y=
              c850f0ed54c1d42f9aa079ad528f8127e5775217 0 iQIVAwUAWTQINUemf/qjRqrOAQjZDw//b4pEgHYfWRVDEmLZtevysfhlJzbSyLAnWgNnRUVdSwl4WRF1r6ds/q7N4Ege5wQHjOpRtx4jC3y/riMbrLUlaeUXzCdqKgm4JcINS1nXy3IfkeDdUKyOR9upjaVhIEzCMRpyzabdYuflh5CoxayO7GFk2iZ8c1oAl4QzuLSspn9w+znqDg0HrMDbRNijStSulNjkqutih9UqT/PYizhE1UjL0NSnpYyD1vDljsHModJc2dhSzuZ1c4VFZHkienk+CNyeLtVKg8aC+Ej/Ppwq6FlE461T/RxOEzf+WFAc9F4iJibSN2kAFB4ySJ43y+OKkvzAwc5XbUx0y6OlWn2Ph+5T54sIwqasG3DjXyVrwVtAvCrcWUmOyS0RfkKoDVepMPIhFXyrhGqUYSq25Gt6tHVtIrlcWARIGGWlsE+PSHi87qcnSjs4xUzZwVvJWz4fuM1AUG/GTpyt4w3kB85XQikIINkmSTmsM/2/ar75T6jBL3kqOCGOL3n7bVZsGXllhkkQ7e/jqPPWnNXm8scDYdT3WENNu34zZp5ZmqdTXPAIIaqGswnU04KfUSEoYtOMri3E2VvrgMkiINm9BOKpgeTsMb3dkYRw2ZY3UAH9QfdX9BZywk6v3kkE5ghLWMUoQ4sqRlTo7mJKA8+EodjmIGRV/kAv1f7pigg6pIWWEyo=
 c49ed51a698ec016d2b4c6b44ca3c3f73cc788 0 iQIcBAABCAAGBQJZXQSmAAoJELnJ3IJKpb3VmTwP/jsxFTlKzWU8EnEhEViiP2YREOD3AXU7685DIMnoyVAsZgxrt0CG6Y92b5sINCeh5B0ORPQ7+xi2Xmz6tX8EeAR+/Dpdx6K623yExf8kq91zgfMvYkatNMu6ZVfywibYZAASq02oKoX7WqSPcQG/OwgtdFiGacCrG5iMH7wRv0N9hPc6D5vAV8/H/Inq8twpSG5SGDpCdKj7KPZiY8DFu/3OXatJtl+byg8zWT4FCYKkBPvmZp8/sRhDKBgwr3RvF1p84uuw/QxXjt+DmGxgtjvObjHr+shCMcKBAuZ4RtZmyEo/0L81uaTElHu1ejsEzsEKxs+8YifnH070PTFoV4VXQyXfTc8AyaqHE6rzX96a/HjQiJnL4dFeTZIrUhGK3AkObFLWJxVTo4J8+oliBQQldIh1H2yb1ZMfwapLnUGIqSieHDGZ6K2ccNJK8Q7IRhTCvYc0cjsnbwTpV4cebGqf3WXZhX0cZN+TNfhh/HGRzR1EeAAavjJqpDam1OBA5TmtJd/lHLIRVR5jyG+r4SK0XDlJ8uSfah7MpVH6aQ6UrycPyFusGXQlIqJ1DYQaBrI/SRJfIvRUmvVz9WgKLe83oC3Ui3aWR9rNjMb2InuQuXjeZaeaYfBAUYACcGfCZpZZvoEkMHCqtTng1rbbFnKMFk5kVy9YWuVgK9Iuh0O5
 ebaed4e315f63157bd157d6ce553c7ab73 0 iQIVAwUAWW9XW0emf/qjRqrOAQhI7A//cKXIM4l8vrWWsc1Os4knXm/2UaexmAwV70TpviKL9RxCy5zBP/EapCaGRCH8uNPOQTkWGR9Aucm3CtxhggCMzULQxxeH86mEpWf1xILWLySPXW/t2f+2zxrwLSAxxqFJtuYv83Pe8CnS3y4BlgHnBKYXH8XXuW8uvfc0lHKblhrspGBIAinx7vPLoGQcpYrn9USWUKq5d9FaCLQCDT9501FHKf5dlYQajevCUDnewtn5ohelOXjTJQClW3aygv/z+98Kq7ZhayeIiZu+SeP+Ay7lZPklXcy6eyRiQtGCa1yesb9v53jKtgxWewV4o6zyuUesdknZ/IBeNUgw8LepqTIJo6/ckyvBOsSQcda81DuYNUChZLYTSXYPHEUmYiz6CvNoLEgHF/oO5p6CZXOPWbmLWrAFd+0+1Tuq8BSh+PSdEREM3ZLOikkXoVzTKBgu4zpMvmBnjliBg7WhixkcG0v5WunlV9/oHAIpsKdL7AatU+oCPulp+xDpTKzRazEemYiWG9zYKzwSMk9Nc17e2tk+EtFSPsPo4iVCXMgdIZSTNBvynKEFXZQVPWVa+bYRdAmbSY8awiX7exxYL10UcpnN2q/AH/F7rQzAmo8eZ3OtD0+3Nk3JRx0/CMyzKLPYDpdUgwmaPb+s2Bsy7f7TfmA7jTa69YqB1/zVwlWULr0=
 af8622863796a0027566f6b646e10d522c4c 0 iQIcBAABCAAGBQJZjJflAAoJELnJ3IJKpb3V19kQALCvTdPrpce5+rBNbFtLGNFxTMDol1dUy87EUAWiArnfOzW3rKBdYxvxDL23BpgUfjRm1fAXdayVvlj6VC6Dyb195OLmc/I9z7SjFxsfmxWilF6U0GIa3W0x37i05EjfcccrBIuSLrvR6AWyJhjLOBCcyAqD/HcEom00/L+o2ry9CDQNLEeVuNewJiupcUqsTIG2yS26lWbtLZuoqS2T4Nlg8wjJhiSXlsZSuAF55iUJKlTQP6KyWReiaYuEVfm/Bybp0A2bFcZCYpWPwnwKBdSCHhIalH8PO57gh9J7xJVnyyBg5PU6n4l6PrGOmKhNiU/xyNe36tEAdMW6svcVvt8hiY0dnwWqR6wgnFFDu0lnTMUcjsy5M5FBY6wSw9Fph8zcNRzYyaeUbasNonPvrIrk21nT3ET3RzVR3ri2nJDVF+0GlpogGfk9k7wY3808091BMsyV3448ZPKQeWiK4Yy4UOUwbKV7YAsS5MdDnC1uKjl4GwLn9UCY/+Q2/2R0CBZ13Tox+Nbo6hBRuRGtFIbLK9j7IIUhhZrIZFSh8cDNkC+UMaS52L5z7ECvoYIUpw+MJ7NkMLHIVGZ2Nxn0C7IbGO6uHyR7D6bdNpxilU+WZStHk0ppZItRTm/htar4jifnaCI8F8OQNYmZ3cQhxx6qV2Tyow8arvWb1NYXrocG
 c91326b23954e6e1c6960d0239511f9530258 0 iQIcBAABCAAGBQJZjKKZAAoJELnJ3IJKpb3VGQkP/0iF6Khef0lBaRhbSAPwa7RUBb3iaBeuwmeic/hUjMoU1E5NR36bDDaF3u2di5mIYPBONFIeCPf9/DKyFkidueX1UnlAQa3mjh/QfKTb4/yO2Nrk7eH+QtrYxVUUYYjwgp4rS0Nd/++I1IUOor54vqJzJ7ZnM5O1RsE7VI1esAC/BTlUuO354bbm08B0owsZBwVvcVvpV4zeTvq5qyPxBJ3M0kw83Pgwh3JZB9IYhOabhSUBcA2fIPHgYGYnJVC+bLOeMWI1HJkJeoYfClNUiQUjAmi0cdTC733eQnHkDw7xyyFi+zkKu6JmU1opxkHSuj4Hrjul7Gtw3vVWWUPufz3AK7oymNp2Xr5y1HQLDtNJP3jicTTG1ae2TdX5Az3ze0I8VGbpR81/6ShAvY2cSKttV3I+2k4epxTTTf0xaZS1eUdnFOox6acElG2reNzx7EYYxpHj17K8N2qNzyY78iPgbJ+L39PBFoiGXMZJqWCxxIHoK1MxlXa8WwSnsXAU768dJvEn2N1x3fl+aeaWzeM4/5Qd83YjFuCeycuRnIo3rejSX3rWFAwZE0qQHKI5YWdKDLxIfdHTjdfMP7np+zLcHt0DV/dHmj2hKQgU0OK04fx7BrmdS1tw67Y9bL3H3TDohn7khU1FrqrKVuqSLbLsxnNyWRbZQF+DCoYrHlIW
 fee7f7d2da04226914c2258cc2884dc27384fd7 0 iQIcBAABCAAGBQJZjOJfAAoJELnJ3IJKpb3VvikP/iGjfahwkl2BDZYGq6Ia64a0bhEh0iltoWTCCDKMbHuuO+7h07fHpBl/XX5XPnS7imBUVWLOARhVL7aDPb0tu5NZzMKN57XUC/0FWFyf7lXXAVaOapR4kP8RtQvnoxfNSLRgiZQL88KIRBgFc8pbl8hLA6UbcHPsOk4dXKvmfPfHBHnzdUEDcSXDdyOBhuyOSzRs8egXVi3WeX6OaXG3twkw/uCF3pgOMOSyWVDwD+KvK+IBmSxCTKXzsb+pqpc7pPOFWhSXjpbuYUcI5Qy7mpd0bFL3qNqgvUNq2gX5mT6zH/TsVD10oSUjYYqKMO+gi34OgTVWRRoQfWBwrQwxsC/MxH6ZeOetl2YkS13OxdmYpNAFNQ8ye0vZigJRA+wHoC9dn0h8c5X4VJt/dufHeXc887EGJpLg6GDXi5Emr2ydAUhBJKlpi2yss22AmiQ4G9NE1hAjxqhPvkgBK/hpbr3FurV4hjTG6XKsF8I0WdbYz2CW/FEbp1+4T49ChhrwW0orZdEQX7IEjXr45Hs5sTInT90Hy2XG3Kovi0uVMt15cKsSEYDoFHkR4NgCZX2Y+qS5ryH8yqor3xtel3KsBIy6Ywn8pAo2f8flW3nro/O6x+0NKGV+ZZ0uo/FctuQLBrQVs025T1ai/6MbscQXvFVZVPKrUzlQaNPf/IwNOaRa
 f72c7b70acfdaf56ab35360584d7845827 0 iQIcBAABCAAGBQJZv+wSAAoJELnJ3IJKpb3VH3kQAJp3OkV6qOPXBnlOSSodbVZveEQ5dGJfG9hk+VokcK6MFnieAFouROoGNlQXQtzj6cMqK+LGCP/NeJEG323gAxpxMzc32g7TqbVEhKNqNK8HvQSt04aCVZXtBmP0cPzc348UPP1X1iPTkyZxaJ0kHulaHVptwGbFZZyhwGefauU4eMafJsYqwgiGmvDpjUFu6P8YJXliYeTo1HX2lNChS1xmvJbop1YHfBYACsi8Eron0vMuhaQ+TKYq8Zd762u2roRYnaQ23ubEaVsjGDUYxXXVmit2gdaEKk+6Rq2I+EgcI5XvFzK8gvoP7siz6FL1jVf715k9/UYoWj9KDNUm8cweiyiUpjHQt0S+Ro9ryKvQy6tQVunRZqBN/kZWVth/FlMbUENbxVyXZcXv+m7OLvk+vyK7UZ7yT+OBzgRr0PyUuafzSVW3e+RZJtGxYGM5ew2bWQ8L6wuBucRYZOSnXXtCw7cKEMlK3BTjfAfpHUdIZIG492R9d6aOECUK/MpNvCiXXaZoh5Kj4a0dARiuWFCZxWwt3bmOg13oQ841zLdzOi/YZe15vCm8OB4Ffg6CkmPKhZhnMwVbFmlaBcoaeMzzpMuog91J1M2zgEUBTYwe/HKiNr/0iilJMPFRpZ+zEb2GvVoc8FMttXi8aomlXf/6LHCC9ndexGC29jIzl41+
 f427b57bf9019c6dc3750baa539dc22c1be50f6 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlnQtVIQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91TTkD/409sWTM9vUH2qkqNTb1IXyGpqzb9UGOSVDioz6rvgZEBgh9D1oBTWnfBXW8sOWR0A7iCL6qZh2Yi7g7p0mKGXh9LZViLtSwwMSXpNiGBO7RVPW+NQ6DOY5Rhr0i08UBiVEkZXHeIVCd2Bd6mhAiUsm5iUh9Jne10wO8cIxeAUnsx4DBdHBMWLg6AZKWllSgN+r9H+7wnOhDbkvj1Cu6+ugKpEs+xvbTh47OTyM+w9tC1aoZD4HhfR5w5O16FC+TIoE6wmWut6e2pxIMHDB3H08Dky6gNjucY/ntJXvOZW5kYrQA3LHKks8ebpjsIXesOAvReOAsDz0drwzbWZan9Cbj8yWoYz/HCgHCnX3WqKKORSP5pvdrsqYua9DXtJwBeSWY4vbIM2kECAiyw1SrOGudxlyWBlW1f1jhGR2DsBlwoieeAvUVoaNwO7pYirwxR4nFPdLDRCQ4hLK/GFiuyr+lGoc1WUzVRNBYD3udcOZAbqq4JhWLf0Gvd5xP0rn1cJNhHMvrPH4Ki4a5KeeK6gQI7GT9/+PPQzTdpxXj6KwofktJtVNqm5sJmJ+wMIddnobFlNNLZ/F7OMONWajuVhh+vSOV34YLdhqzAR5XItkeJL6qyAJjNH5PjsnhT7nMqjgwriPz6xxYOLJWgtK5ZqcSCx4gWy9KJVVja8wJ7rRUg==
 e2454b60e5936f5e77498cab2648db469504487 0 iQJVBAABCAA/FiEEOoFVFj0OIKUw/LeGR6Z/+qNGqs4FAlnqRBUhHGtidWxsb2NrK21lcmN1cmlhbEByaW5nd29ybGQub3JnAAoJEEemf/qjRqrOAQQP/28EzmTKFL/RxmNYePdzqrmcdJ2tn+s7OYmGdtneN2sESZ4MK0xb5Q8Mkm+41aXS52zzJdz9ynwdun8DG4wZ3sE5MOG+GgK6K0ecOv1XTKS3a2DkUM0fl5hlcXN7Zz7m7m5M6sy6vSxHP7kTyzQWt//z175ZLSQEu1a0nm/BLH+HP9e8DfnJ2Nfcnwp32kV0Nj1xTqjRV1Yo/oCnXfVvsxEJU+CDUGBiLc29ZcoWVbTw9c1VcxihJ6k0pK711KZ+bedSk7yc1OudiJF7idjB0bLQY6ESHNNNjK8uLppok0RsyuhvvDTAoTsl1rMKGmXMM0Ela3/5oxZ/5lUZB73vEJhzEi48ULvstpq82EO39KylkEfQxwMBPhnBIHQaGRkl7QPLXGOYUDMY6gT08Sm3e8/NqEJc/AgckXehpH3gSS2Ji2xg7/E8H5plGsswFidw//oYTTwm0j0halWpB521TD2wmjkjRHXzk1mj0EoFQUMfwHTIZU3E8flUBasD3mZ9XqZJPr66RV7QCrXayH75B/i0CyNqd/Hv5Tkf2TlC3EkEBZwZyAjqw7EyL1LuS936sc7fWuMFsH5k/fwjVwzIc1LmP+nmk2Dd9hIC66vec4w1QZeeAXuDKgOJjvQzj2n+uYRuObl4kKcxvoXqgQN0glGuB1IW7lPllGHR1kplhoub
 ccb43d4cf01d013ae05917ec4f305509f851b2d 0 iQJVBAABCAA/FiEEOoFVFj0OIKUw/LeGR6Z/+qNGqs4FAln6Qp8hHGtidWxsb2NrK21lcmN1cmlhbEByaW5nd29ybGQub3JnAAoJEEemf/qjRqrOJ8MP/2ufm/dbrFoE0F8hewhztG1vS4stus13lZ9lmM9kza8OKeOgY/MDH8GaV3O8GnRiCNUFsVD8JEIexE31c84H2Ie7VQO0GQSUHSyMCRrbED6IvfrWp6EZ6RDNPk4LHBfxCuPmuVHGRoGZtsLKJBPIxIHJKWMlEJlj9BZuUxZp/8kurQ6CXwblVbFzXdOaZQlioOBH27Bk3S0+gXfJ+wA2ed5XOQvT9jwjqC8y/1t8obaoPTpzyAvb9NArG+9RT9vfNN42aWISZNwg6RW5oLJISqoGrAes6EoG7dZfOC0UoKMVYXoNvZzJvVlMHyjugIoid+WI+V8y9bPrRTfbPCmocCzEzCOLEHQta8roNijB0bKcq8hmQPHcMyXlj1Srnqlco49jbhftgJoPTwzb10wQyU0VFvaZDPW/EQUT3M/k4j3sVESjANdyG1iu6EDV080LK1LgAdhjpKMBbf6mcgAe06/07XFMbKNrZMEislOcVFp98BSKjdioUNpy91rCeSmkEsASJ3yMArRnSkuVgpyrtJaGWl79VUcmOwKhUOA/8MXMz/Oqu7hvve/sgv71xlnim460nnLw6YHPyeeCsz6KSoUK3knFXAbTk/0jvU1ixUZbI122aMzX04UgPGeTukCOUw49XfaOdN+x0YXlkl4PsrnRQhIoixY2gosPpK4YO73G
              cabc840ffdee8a72f3689fb77dd74d04fdc2bc04 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAloB+EYQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91TfwEAC/pYW7TC8mQnqSJzde4yiv2+zgflfJzRlg5rbvlUQl1gSBla3sFADZcic0ebAc+8XUu8eIzyPX+oa4wjsHvL13silUCkUzTEEQLqfKPX1bhA4mwfSDb5A7v2VZ5q8qhRGnlhTsB79ML8uBOhR/Bigdm2ixURPEZ37pWljiMp9XWBMtxPxXn/m0n5CDViibX6QqQCR4k3orcsIGd72YXU6B8NGbBN8qlqMSd0pGvSF4vM2cgVhz7D71+zU4XL/HVP97aU9GsOwN9QWW029DOJu6KG6x51WWtfD/tzyNDu7+lZ5/IKyqHX4tyqCIXEGAsQ3XypeHgCq5hV3E6LJLRqPcLpUNDiQlCg6tNPRaOuMC878MRIlffKqMH+sWo8Z7zHrut+LfRh5/k1aCh4J+FIlE6Hgbvbvv2Z8JxDpUKl0Tr+i0oHNTapbGXIecq1ZFR4kcdchodUHXBC2E6HWR50/ek5YKPddzw8WPGsBtzXMfkhFr3WkvyP2Gbe2XJnkuYptTJA+u2CfhrvgmWsYlvt/myTaMZQEzZ+uir4Xoo5NvzqTL30SFqPrP4Nh0n9G6vpVJl/eZxoYK9jL3VC0vDhnZXitkvDpjXZuJqw/HgExXWKZFfiQ3X2HY48v1gvJiSegZ5rX+uGGJtW2/Mp5FidePEgnFIqZW/yhBfs2Hzj1D2A==
              a92b9f8e11ba330614cdfd6af0e03b15c1ff3797 0 iQJVBAABCAA/FiEEOoFVFj0OIKUw/LeGR6Z/+qNGqs4FAlohslshHGtidWxsb2NrK21lcmN1cmlhbEByaW5nd29ybGQub3JnAAoJEEemf/qjRqrO7P8P/1qGts96acEdB9BZbK/Eesalb1wUByLXZoP8j+1wWwqh/Kq/q7V4Qe0z1jw/92oZbmnLy2C8sDhWv/XKxACKv69oPrcqQix1E8M+07u88ZXqHJMSxkOmvA2Vimp9EG1qgje+qchgOVgvhEhysA96bRpEnc6V0RnBqI5UdfbKtlfBmX5mUE/qsoBZhly1FTmzV1bhYlGgNLyqtJQpcbA34wyPoywsp8DRBiHWrIzz5XNR+DJFTOe4Kqio1i5r8R4QSIM5vtTbj5pbsmtGcP2CsFC9S3xTSAU6AEJKxGpubPk3ckNj3P9zolvR7krU5Jt8LIgXSVaKLt9rPhmxCbPrLtORgXkUupJcrwzQl+oYz5bkl9kowFa959waIPYoCuuW402mOTDq/L3xwDH9AKK5rELPl3fNo+5OIDKAKRIu6zRSAzBtyGT6kkfb1NSghumP4scR7cgUmLaNibZBa8eJj92gwf+ucSGoB/dF/YHWNe0jY09LFK3nyCoftmyLzxcRk1JLGNngw8MCIuisHTskhxSm/qlX7qjunoZnA3yy9behhy/YaFt4YzYZbMTivt2gszX5ktToaDqfxWDYdIa79kp8G68rYPeybelTS74LwbK3blXPI3I1nddkW52znHYLvW6BYyi+QQ5jPZLkiOC+AF0q+c4gYmPaLVN/mpMZjjmB
 b6df1b5adbdf647cf5c6675b40575e1b197c60 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlpmbwIQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91W4BD/4h+y7QH7FkNcueOBrmdci7w1apkPX7KuknKxf8+FmA1QDGWYATnqD6IcAk3+f4reO4n9qc0y2BGrIz/pyTSIHvJW+ORrbPCKVrXlfUgkUK3TumtRObt8B75BVBBNaJ93r1yOALpo/K8wSwRrBF+Yl6aCoFiibUEbfcfaOAHVqZXKC1ZPtLRwq5NHIw0wWB0qNoAXj+FJV1EHO7SEjj2lXqw/r0HriQMdObWLgAb6QVUq7oVMpAumUeuQtZ169qHdqYfF1OLdCnsVBcwYEz/cBLC43bvYiwFxSkbAFyl656caWiwA3PISFSzP9Co0zWU/Qf8f7dTdAdT/orzCfUq8YoXqryfRSxi+8L8/EMxankzdW73Rx5X+0539pSq+gDDtTOyNuW6+CZwa5D84b31rsd+jTx8zVm3SRHRKsoGF2EEMQkWmDbhIFjX5W1fE84Ul3umypv+lPSvCPlQpIqv2hZmcTR12sgjdBjU8z+Zcq22SHFybqiYNmWpkVUtiMvTlHMoJfi5PI6xF8D2dxV4ErG+NflqdjaXydgnbO6D3/A1FCASig0wL4jMxSeRqnRRqLihN3VaGG2QH6MLJ+Ty6YuoonKtopw9JNOZydr/XN7K5LcjX1T3+31qmnHZyBXRSejWl9XN93IDbQcnMBWHkz/cJLN0kKu4pvnV8UGUcyXfA==
              d334afc585e29577f271c5eda03378736a16ca6b 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlpzZuUQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91TiDEADDD6Tn04UjgrZ36nAqOcHaG1ZT2Cm1/sbTw+6duAhf3+uKWFqi2bgcdCBkdfRH7KfEU0GNsPpiC6mzWw3PDWmGhnLJAkR+9FTBU0edK01hkNW8RelDTL5J9IzIGwrP4KFfcUue6yrxU8GnSxnf5Vy/N5ZZzLV/P3hdBte5We9PD5KHPAwTzzcZ9Wiog700rFDDChyFq7hNQ3H0GpknF6+Ck5XmJ3DOqt1MFHk9V4Z/ASU59cQXKOeaMChlBpTb1gIIWjOE99v5aY06dc1WlwttuHtCZvZgtAduRAB6XYWyniS/7nXBv0MXD3EWbpH1pkOaWUxw217HpNP4g9Yo3u/i8UW+NkSJOeXtC1CFjWmUNj138IhS1pogaiPPnIs+H6eOJsmnGhN2KbOMjA5Dn9vSTi6s/98TarfUSiwxA4L7fJy5qowFETftuBO0fJpbB8+ZtpnjNp0MMKed27OUSv69i6BmLrP+eqk+MVO6PovvIySlWAP9/REM/I5/mFkqoI+ruT4a9osNGDZ4Jqb382b7EmpEMDdgb7+ezsybgDfizuaTs/LBae7h79o1m30DxZ/EZ5C+2LY8twbGSORvZN4ViMVhIhWBTlOE/iVBOj807Y2OaUURcuLfHRmaCcfF1uIzg0uNB/aM/WSE0+AXh2IX+mipoTS3eh/V2EKldBHcOQ==
 aadf7a3264b03c8b09efce715bc41e6ab4a9b 0 iQJVBAABCAA/FiEEOoFVFj0OIKUw/LeGR6Z/+qNGqs4FAlqe5w8hHGtidWxsb2NrK21lcmN1cmlhbEByaW5nd29ybGQub3JnAAoJEEemf/qjRqrO1lUQAK6+S26rE3AMt6667ClT+ubPl+nNMRkWJXa8EyPplBUGTPdMheViOe+28dCsveJxqUF7A4TMLMA/eIj4cRIwmVbBaivfQKnG5GMZ+9N6j6oqE/OAJujdHzzZ3+o9KJGtRgJP2tzdY/6qkXwL3WN6KULz7pSkrKZLOiNfj4k2bf3bXeB7d3N5erxJYlhddlPBlHXImRkWiPR/bdaAaYJq+EEWCbia6MWXlSAqEjIgQi+ytuh/9Z+QSsJCsECDRqEExZClqHGkCLYhST99NqqdYCGJzAFMgh+xWxZxI0LO08pJxYctHGoHm+vvRVMfmdbxEydEy01H6jX+1e7Yq44bovIiIOkaXCTSuEBol+R5aPKJhgvqgZ5IlcTLoIYQBE3MZMKZ89NWy3TvgcNkQiOPCCkKs1+DukXKqTt62zOTxfa6mIZDCXdGai6vZBJ5b0yeEd3HV96yHb9dFlS5w1cG7prIBRv5BkqEaFbRMGZGV31Ri7BuVu0O68Pfdq+R+4A1YLdJ0H5DySe2dGlwE2DMKhdtVu1bie4UWHK10TphmqhBk6B9Ew2+tASCU7iczAqRzyzMLBTHIfCYO2R+5Yuh0CApt47KV23OcLje9nORyE2yaDTbVUPiXzdOnbRaCQf7eW5/1y/LLjG6OwtuETTcHKh7ruko+u7rFL96a4DNlNdk
 bba684efde7f45add05f737952093bb2aa07155 0 iQJVBAABCAA/FiEEOoFVFj0OIKUw/LeGR6Z/+qNGqs4FAlqe6dkhHGtidWxsb2NrK21lcmN1cmlhbEByaW5nd29ybGQub3JnAAoJEEemf/qjRqrOJmIQALUVCoWUFYYaRxGH4OpmIQ2o1JrMefvarFhaPY1r3+G87sjXgw15uobEQDtoybTUYbcdSxJQT1KE1FOm3wU0VyN6PY9c1PMEAVgJlve0eDiXNNlBsoYMXnpq1HidZknkjpXgUPdE/LElxpJJRlJQZlS29bkGmEDZQBoOvlcZoBRDSYcbM07wn7d+1gmJkcHViDBMAbSrudfO0OYzDC1BjtGyKm7Mes2WB1yFYw+ySa8hF/xPKEDvoZINOE5n3PBJiCvPuTw3PqsHvWgKOA1Obx9fATlxj7EHBLfKBTNfpUwPMRSH1cmA+qUS9mRDrdLvrThwalr6D3r2RJ2ntOipcZpKMmxARRV+VUAI1K6H0/Ws3XAxENqhF7RgRruJFVq8G8EcHJLZEoVHsR+VOnd/pzgkFKS+tIsYYRcMpL0DdMF8pV3xrEFahgRhaEZOh4jsG3Z+sGLVFFl7DdMqeGs6m/TwDrvfuYtGczfGRB0wqu8KOwhR1BjNJKcr4lk35GKwSXmI1vk6Z1gAm0e13995lqbCJwkuOKynQlHWVOR6hu3ypvAgV/zXLF5t8HHtL48sOJ8a33THuJT4whbXSIb9BQXu/NQnNhK8G3Kly5UN88vL4a3sZi/Y86h4R2fKOSib/txJ3ydLbMeS8LlJMqeF/hrBanVF0r15NZ2CdmL1Qxim
 de7bd407251af2bc98e5b809c8598ee95830daf 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlrE4p0QHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91c4UD/4tC+mBWxBw/JYm4vlFTKWLHopLEa1/uhFRK/uGsdgcCyexbCDbisjJpl3JTQb+wQDlZnUorm8zB206y418YqhJ7lCauRgcoqKka0e3kvKnwmklwmuGkwOIoruWxxhCcgRCT4C+jZ/ZE3Kre0CKnUvlASsHtbkqrCqFClEcIlPVohlccmjbpQXN+akB40tkMF5Xf0AMBPYG7UievmeHhz3pO/yex/Uc6RhgWAqD4zjA1bh+3REGs3CaoYgKUTXZw/XYI9cqAI0FobRuXSVbq2dqkXCFLfD+WizxUz55rZA+CP4pqLndwxGm4fLy4gk2iLHxKfrHsAul7n5e4tHmxDcOOa1K0fIJDBijuXoNfXN7nF4NQUlfpmtOxUxfniVohvXJeYV8ecepsDMSFqDtEtbdhsep5QDx85lGLNLQAA1f36swJzLBSqGw688Hjql2c9txK2eVrVxNp+M8tqn9qU/h2/firgu9a2DxQB45M7ISfkutmpizN5TNlEyElH0htHnKG7+AIbRAm4novCXfSzP8eepk0kVwj9QMIx/rw4aeicRdPWBTcDIG0gWELb0skunTQqeZwPPESwimntdmwCxfFksgT0t79ZEDAWWfxNLhJP/HWO2mYG5GUJOzNQ4rj/YXLcye6A4KkhvuZlVCaKAbnm60ivoG082HYuozV4qPOQ==
              ed5448edcbfa747b9154099e18630e49024fd47b 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlrXnuoQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91fSHEACBVg4FsCE2nN5aEKAQb7l7rG4XTQ9FbvoTYB3tkvmsLQSRfh2GB2ZDBOI7Vswo2UxXupr4qSkUQbeHrwrk9A1s5b/T5e4wSKZuFJOrkwLVZDFfUHumKomqdoVj/D8+LDt7Rz+Wm7OClO/4dTAsl2E4rkl7XPtqjC3jESGad8IBANlPVBhNUMER4eFcPZzq1qi2MrlJKEKpdeZEWJ/ow7gka/aTLqHMfRwhA3kS5X34Yai17kLQZGQdWISWYiM9Zd2b/FSTHZGy8rf9cvjXs3EXfEB5nePveDrFOfmuubVRDplO+/naJjNBqwxeB99jb7Fk3sekPZNW/NqR/w1jvQFA3OP9fS2g1OwfXMWyx6DvBJNfQwppNH3JUvA5PEiorul4GJ2nuubXk+Or1yzoRJtwOGz/GQi2BcsPKaL6niewrInFw18jMVhx/4Jbpu+glaim4EvT/PfJ5KdSwF7pJxsoiqvw7A2C2/DsZRbCeal9GrTulkNf/hgpCJOBK1DqVVq1O5MI/oYQ69HxgMq9Ip1OGJJhse3qjevBJbpNCosCpjb3htlo4go29H8yyGJb09i05WtNW2EQchrTHrlruFr7mKJ5h1mAYket74QQyaGzqwgD5kwSVnIcwHpfb8oiJTwA5R+LtbAQXWC/fFu1g1KEp/4hGOQoRU04+mYuPsrzaA==
 ec874717d8a93b19e0d50628443e0ee5efab3a9 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlraM3wQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91RAJEACSnf/HWwS0/OZaqz4Hfh0UBgkXDmH1IC90Pc/kczf//WuXu5AVnnRHDziOlCYYZAnZ2iKu0EQI6GT2K2garaWkaEhukOnjz4WADVys6DAzJyw5iOXeEpIOlZH6hbYbsW3zVcPjiMPo8cY5tIYEy4E/8RcVly1SDtWxvt/nWYQd2MxObLrpU7bPP6a2Db4Vy8WpGRbZRJmOvDNworld5rB5M/OGgHyMa9hg2Hjn+cLtQSEJY4O92A6h2hix9xpDC7zzfoluD2piDslocTm/gyeln2BJJBAtr+aRoHO9hI0baq5yFRQLO8aqQRJJP8dXgYZIWgSU/9oVGPZoGotJyw24iiB37R/YCisKE+cEUjfVclHTDFCkzmYP2ZMbGaktohJeF7EMau0ZJ8II5F0ja3bj6GrwfpGGY5OOcQrzIYW7nB0msFWTljb34qN3nd7m+hQ5hji3Hp9CFXEbCboVmm46LqwukSDWTmnfcP8knxWbBlJ4xDxySwTtcHAJhnUmKxu7oe3D/0Ttdv7HscI40eeMdr01pLQ0Ee3a4OumQ1hn+oL+o+tlqg8PKT20q528CMHgSJp6aIlU7pEK81b+Zj6B57us4P97qSL6XLNUIfubADCaf/KUDwh1HvKhHXV2aRli1GX1REFsy0ItGZn0yhQxIDJKc/FKsEMBKvlVIHGQFw==
 cac550aea66d19c601e45efd1b7bd08d7c40 0 iQJVBAABCAA/FiEEOoFVFj0OIKUw/LeGR6Z/+qNGqs4FAlruOCQhHGtidWxsb2NrK21lcmN1cmlhbEByaW5nd29ybGQub3JnAAoJEEemf/qjRqrOENQQAI1ttaffqYucUEyBARP1GDlZMIGDJgNG7smPMU4Sw7YEzB9mcmxnBFlPx/9n973ucEnLJVONBSZq0VWIKJwPp1RMBpAHuGrMlhkMvYIAukg5EBN3YpA1UogHYycwLj2Ye7fNgiN5FIkaodt9++c4d1Lfu658A2pAeg8qUn5uJ77vVcZRp988u9eVDQfubS8P6bB4KZc87VDAUUeXy+AcS9KHGBmdRAabwU4m09VPZ4h8NEj3+YUPnKXBaNK9pXK5pnkmB8uFePayimnw6St6093oylQTVw/tfxGLBImnHw+6KCu2ut9r5PxXEVxVYpranGbS4jYqpzRtpQBxyo/Igu7fqrioR2rGLQL5NcHsoUEdOC7VW+0HgHjXKtRy7agmcFcgjFco47D3hor7Y16lwgm+RV2EWQ/u2M4Bbo1EWj1oxQ/0j5DOM5UeAJ3Jh64gb4sCDqJfADR8NQaxh7QiqYhn69IcjsEfzU/11VuqWXlQgghJhEEP/bojRyM0qee87CKLiTescafIfnRsNQhyhsKqdHU1QAp29cCqh3mzNxJH3PDYg4fjRaGW4PM7K5gmSXFn/Ifeza0cuZ4XLdYZ76Z1BG80pqBpKZy1unGob+RpItlSmO5jQw7OoRuf0q3Id92gawUDDLuQ7Xg3zOVqV8/wJBlHM7ZUz162bnNsO5Hn
 c5ced5276d6e7d54f7c3dadf5247b7ee98ec79c 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlsYGdAQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91S3fEACmrG3S5eAUhnKqkXFe+HZUwmUvLKRhyWDLlWQzEHaJZQCFWxqSM1ag7JtAx3WkWwmWrOZ0+T/w/xMv81h9JAv9RsoszUT/RH4RsnWoc2ddcK93Q/PrNJ29kFjvC8j3LF42WfHEIeNqAki5c3GbprUL86KG7XVYuMvpPI/SeNSz8siPaKjXo6sg6bAupPCyapisTmeRHcCUc5UfeTTq4YQdS9UI0p9Fo8/vcqmnWY6XnQCRYs2U8Y2I2QCJBHBE5p4KrxrFsAdPWMCg0dJT0goSbzpfDjukPHQaAnUKjCtXCwrzA/KY8fDH9hm5tt1FnC6nl6BRpEHRoHqTfE1ag2QktJZTn5+JWpzz85qFDl5ktmxj1gS80jkOUJ2699RykBy7NACu+TtLJdBk+E1TN0pAU+zsrTSGiteuikEBjQP/8i4whUZCFIHLPgVlxrHWwn0/oszj1Q/u86sCxnYTflR2GLZs3fbSGBEKDDrjqwetxMlwi/3Qhf0PN9aAI7S13YnA89tGLGRLTsVsOoKiQoTExQaCUpE5jFYBLVjsTPh2AjPhG3Zaf7R5ZIvW4CbVYORNTMaYhFNnFyczILJLRid+INHLVifNiJuaLiAFD5Izq9Me4H+GpwB5AI7aG1r+01Si2KbqqpdfoK430UeDV+U/MvEU7v0RoeF30M7uVYv+kg==
 b63a6743010dfdbf8a8154186e119949bdaa1cc 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAls7n+0QHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91XVGEAC1aPuUmW9R0QjWUmyY4vMO7AOT4F1sHKrkgNaoG/RCvczuZOCz/fGliEKQ52pkvThrOgOvNfJlIGOu91noLKsYUybO8eeTksCzc7agUjk6/Xsed35D8gNEPuiVTNu379sTQRnOA2T/plQnVCY2PjMzBe6nQ2DJYnggJelCUxuqUsLM76OvMEeNlXvyxZmyAcFT5dfSBYbjAt0kklRRQWgaug3GwLJY/+0tmXhq0tCpAF6myXoVQm/ynSxjR+5+2/+F5nudOQmDnL0zGayOAQU97RLAAxf1L+3DTRfbtxams9ZrGfRzQGcI1d4I4ernfnFYI19kSzMPcW4qI7gQQlTfOzs8X5d2fKiqUFjlgOO42hgM6cQv2Hx3u+bxF00sAvrW8sWRjfMQACuNH3FJoeIubpohN5o1Madv4ayGAZkcyskYRCs9X40gn+Q9gv34uknjaF/mep7BBl08JC9zFqwGaLyCssSsHV7ncekkUZfcWfq4TNNEUZFIu7UtsnZYz0aYrueAKMp+4udTjfKKnSZL2o0n1g11iH9KTQO/dWP7rVbu/OIbLeE+D87oXOWGfDNBRyHLItrM70Vum0HxtFuWc1clj8qzF61Mx0umFfUmdGQcl9DGivmc7TLNzBKG11ElDuDIey6Yxc6nwWiAJ6v1H5bO3WBi/klbT2fWguOo5w==
              e90130af47ce8dd53a3109aed9d15876b3e7dee8 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAltQ1bUQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91RQVD/9NA5t2mlt7pFc0Sswktc5dI8GaSYxgeknacLkEdkYx9L+mzg77G7TGueeu5duovjdI/vDIzdadGtJJ+zJE5icCqeUFDfNZNZLQ+7StuC8/f+4i/DaCzjHJ4tDYd0x6R5efisLWRKkWoodI1Iit7gCL493gj1HZaIzRLaqYkbOk3PhOEkTcov2cnhb4h54OKm07qlg6PYH507WGmmTDDnhL9SwdfBXHA2ps9dCe52NzPMyebXoZYA9T5Yz67eQ8D+YCh9bLauA59dW0Iyx59yGJ0tmLwVKBgbUkynAknwk/hdNlF7r6wLqbR00NLKmAZl8crdVSqFUU/vAsPQLn3BkbtpzqjmisIq2BWEt/YWYZOHUvJoK81cRcsVpPuAOIQM/rTm9pprTq7RFtuVnCj+QnmWwEPZJcS/7pnnIXte3gQt76ovLuFxr7dq99anEA7gnTbSdADIzgZhJMM8hJcrcgvbI4xz0H1qKn3webTNl/jPgTsNjAPYcmRZcoU2wUIR+OPhZvfwhvreRX0dGUV6gqxWnx3u3dsWE9jcBIGlNfYnIkLXyqBdOL6f4yQoxaVjRg/ScEt3hU17TknuPIDOXE/iMgWnYpnTqKBolt/Vbx7qB1OiK7AmQvXY1bnhtkIfOoIwZ9X1Zi2vmV1Wz4G0a5Vxq5eNKpQgACA2HE0MS2HQ==
 ac6a72308a215e6086fbced347ec10aa963b0a 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlthwaIQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91atOD/0de4nA55WJpiQzAqTg4xWIRZB6y0pkQ8D4cKNQkNiwPQAdDEPf85RuYmoPusNxhM40qfJlmHOw8sbRaqqabhVBPEzL1DpKe4GBucagLZqoL3pycyMzhkhzMka2RJT6nekCchTKJTIs2gx4FOA/QwaFYNkXFfguAEvi01isVdMo0GFLQ7pf7wU8UO1PPdkYphH0xPUvsreQ3pR3+6WwMLovk4JYW4cSaM4YkLlqJQPSO2YAlyXAwiQRvu2A227ydVqHOgLeV5zMQPy2v2zTgl2AoMdWp8+g2lJrYwclkNR+LAk5OlGYamyZwlmsTO7OX3n7xJYtfjbqdoqEKhO1igMi3ZSjqwkaBxxkXxArrteD19bpUyInTjbwTRO3mSe5aNkEDGoOYWn8UOn5ZkeEo7NyhP4OTXqyxQs9rwjD79xZk+6fGB777vuZDUdLZYRQFOPEximpmCGJDrZWj5PeIALWkrRGWBl2eFJ5sl6/pFlUJDjDEstnrsfosp6NJ3VFiD9EunFWsTlV2qXaueh9+TfaSRmGHVuwFCDt7nATVEzTt8l74xsL3xUPS4u9EcNPuEhCRu1zLojCGjemEA29R9tJS8oWd6SwXKryzjo8SyN7yQVSM/yl212IOiOHTQF8vVZuJnailtcWc3D4NoOxntnnv8fnd1nr8M5QSjYQVzSkHw==
              ede3bf31fe63677fdf5bd8db687977d4e3d792ed 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAluOq84QHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91ao3D/oC9zKNbk+MMUP0cSfl+ESRbP/sAI466IYDkr9f1klooIFMsdqCd16eS36DVwIwrBYapRaNszC6Pg0KCFKCdeAWJLcgeIawwOkZPrLKQmS3I9GTl9gxtExeFvRryaAdP1DAPEU6JkyHo3xmURkJB58VjuBquZz4cYnL2aE1ag04CWAoRFiLu6bt1hEZ8pONU6cbDpHaJVyUZmJRB+llpybgdLnlBTrhfWjNofTh8MM6+vz67lIienYoSbepY+029J98phBTV+UEfWSBWw1hcNT/+QmOBGWWTLfBARsNDZFeYgQQOo3gRghKO7qUA/hqzDTmMG4/a2obs0LGsBlcMZ1Ky//zhdAJ/EN7uH9svM1t1fkw1RgvftmybptK5KiusZ9AWhnggHSwZtj1I6i/sojqsj9MrtdrD+1LfiKuAv/FtcMHSeff8IfItrd2B67JIj4wCzU8vDrAbAAqODHx7AnssvNbYrH2iOigSINFMNJoLU/xLxBhTxitU2Zf8puHA4CQ3+BybgOH9HPqCtGcVAB7bcp4hiezGrachM+2oec2YwcGCpIobMPl43cmWkLhtGF5qfl7APVfbo18UXk8ZGmBY8YAYwEyksk2SBMJV6+XHw9J7uaaugc3uN8PuMVLqvSMpWN1ZdRsSkxrOJK+UNW7kbUi0wHnsV1rN0U0BIfVOQ==
 cb1a79010ac50c58cd84e6f50c4556bf2a4c 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAluyfokQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91eWpD/0eu/JfD6SfaT4Ozd2767ojNIW4M9BgcRH/FehFBd/3iQ/YQmaMVd6GmdaagM5YUpD9U+rDK95l8rUstuTglXeKD2SVcDM4Oq9ToyZyp5aizWjkxRxHT60W95G5FQO/tBbs63jfNrVDWDElbkpcn/gUG6JbX+q/S/mKd6WsuwNQC1N4VOWp0OWCmFGBWN7t/DqxGLGEajJM0NB97/r/IV6TzrGtaPf1CXaepDVvZwIIeas/eQgGInyqry7WBSn5sCUq4opIh1UigMABUAgzIZbgTg8NLGSmEgRgk0Vb4K+pLejLLDb5YD7ZwuUCkbd8oJImKQfU6++Ajd70TbNQRvVhMtd15iCtOOjLR+VNkUiDXm0g1U53sREMLdj/+SMJZB6Z18DotdgpaeCmwA/wWijXOdt76xwUKjByioxyQilPrzrWGaoSG4ynjiD2Y+eSRS1DxbpDgt4YEuiVA6U3ay99oW7KkhFjQsUtKl4SJ5SQWiEofvgtb2maNrXkPtKOtNRHhc61v73zYnsxtl2qduC99YOTin90FykD80XvgJZfyow/LICb77MNGwYBsJJMDQ3jG1YyUC2CQsb8wyrWM4TO3tspKAQPyMegUaVtBqw7ZhgiC3OXEes+z+AL5YRSZXALfurXPYbja8M8uGL2TYB3/5bKYvBXxvfmSGIeY6VieQ==
 ec6f1320df26f3133ec40f3de866ea0695fd7 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlvOG20QHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91eZ+EACb/XfPWaMkwIX54JaFWtL/nVkDcaL8xLVzlI+PxL0ZtHdQTGVQNp5f1BnZU9RKPZ9QOuz+QKNvb4hOOXBwmCi2AAjmTYUqtKThHmOT50ZRICkllY+YlZ3tI6JXRDhh7pSXaus8jBFG/VwuUlVmK5sA2TP+lIJijOgV9rThszfS4Q2I8sBTIaeZS1hyujFxGRO++tjYR+jPuo/98FhqJ5EylVYvKmnflWkOYLFNFqgDI6DQs7Dl+u2nrNAzZJQlgk+1ekd66T3WyK8U3tcFLZGRQ+gpzINH0Syn6USaaE+0nGi4we1hJS8JK0txWyHXJGNZYaWQAC2l1hIBfA38azwVLSe2w9JatXhS3HWByILy8JkEQ2kSo1xTD4mBkszZo/kWZpZRsAWydxCnzhNgKmTJYxASFTTX1mpdX4EzJBOs/++52y1OjVc0Ko0+6vSwxsC6zgIGJx1Os7vVgWHql0XbDmJ1NDdNmz7q5HjFcbNOWScKf6UGcBKV4dpW1w+7CvdoMFHUsVTa2zn6YOki3NEt0GWLXq+0aXbHSw8XETcyunQKjDi9ddKOw0rYGip6EKUKhOILZimQ0lgYRE23RDdT5Tl2D8s66SUuipgP9vGjbMaE/FhO3OAb7406jyCrOVfDis7sK0Hvw074GhIfZUjA4W4Ey2TeExCZHHhBdoPTrg==
              a91a2837150bdcb27ae76b3646e6c93cd6a15904 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlvclPMQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91fc0EADF/62jqCARFaQRRcKpobPNBZupwSbnQ7E296ZRwHdZvT8CVGfkWBUIStyh+r8bfmBzzea6d9/SUoRqCoV9rwCXuRbeCZZRMMkqx9IblV3foaIOxyQi0KE2lpzGJAHxPiNxD3czZV4B+P6X2wNmG9OLjmHyQ7o64GvPAJ+Ko/EsND1tkx4qB16mEuEHVxtfaG6hbjgpLekIA3+3xur3E8cWBsNO28HtQBK83r2qURwv6eG3TfkbmiE+Ie5TNC15LPVhAOHVSD7miZdI82uk2063puCKZxIJXsy7EMjHfChTM9c7B4+TdEBjms3y+Byz2EV7kRfjplGOnBbYvfY7qiteTn/22+rLrTTQNkndDN/Sqr1DjwsvxKDeIfsqgXzGQPupLOrGdGf4ILAtA0Reme7VKNN5Px6dNxnjKKwsnSrKTQ7ZcmD+W1LKlL63lBEQvEy+TLmmFLfM2xvvBxL5177AKZrj/8gMUzEi1K2MelDGrasA7OSjTlABoleDvZzVOf1nC0Bv83tFc8FeMHLwNOxkFSsjORvZuIH/G9BYUTAd96iLwQRBxXLOVNitxAOQT+s3hs7JEaUzTHlAY+lNeFAxUujb4H0V40Xgr20O1u7PJ53tzApIrg9JQPgvUXntmRs8fpNo6f3P6Sg8XtaCCHIUAB6qTHiose56llf6bzl66A==
 c8c54cf97256f4468da2eb4dbee24f7f3888e71 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlwG+eIQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91YqSD/9IAwdaPrOeiT+DVBW2x33oFeY1X1f5CBG/vCJptalOd2QDIsD0ANEzQHmzV25RKD851v155Txt/BPlkuBfO/kg0BbOoqTpGZk+5CcoFWeyhJct2CxtCLdEpyZ/98/htMR4VfWprCX2GHXPjS813l9pebsN3WgBUOc2VaUdHNRoAGsMVgWC5BWwNP4XSA9oixFL/O4aGLQ6pPfP3vmMFySWXWnIN8gUZ4sm53eKaT0QCICAgzFh+GzRd81uACDfoJn1d8RS9GK+h6j8x0crLY5CpQQy8lRVkokvc0h6XK44ofc57p9GHAOfprHY3DbBhD9H6fLAf5raUsqPkLRYVGqhg8bOsBr3vJ56hiXJYOYPZSYXGjnHRcUrgfPVrY+6mPTeCIQMPmWBHwYH5Tc5TLrPuxxCL4wVywqGbfmIVP+WFUikkykAAwuPOZAswxJJOB0gsnnxcApmTeXRznBXyvzscMlWVZiMjzflKRRJ9V5RI4Fdc6n1wQ4vuLSO4AUnIypIsV6ZFAOBuFKH7x6nPG0tP3FYzcICaMOPbxEx3LStnuU+UuEs6TIxM6IiR3LPiiDGZ2BA2gjJhDxQFV8hAl8KDO3LsYuyUQCv3RTAP+YejH21bIXdnwDlNqy8Hrd53rq7jZsdb2pMVvOZZ3VmIu64f+jVkD/r5msDUkQL3M9jwg==
 f092b2cd9691e2a55d198f717b231af9be6f9 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlwz6DUQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91SbtD/47TJkSFuDJrvrpLuZROeR48opM8kPtMdbFKZxmeUtap/1q1ahBcA8cnkf5t5iEna57OkPfx0FVw7zupFZSD970q8KeQa1C1oRf+DV83rkOqMEzTLmDYZ5YWWILyDb2NrSkBzArhLNhEtWrFFo9uoigwJWiyNGXUkjVd7XUaYvxVYvnHJcmr98l9sW+RxgV2Cm/6ImeW6BkSUjfrJpZlHUecxcHIaDVniSCVzVF7T+tgG0+CxpehmRrPE/qlPTY2DVHuG6ogwjmu7pWr4kW3M6pTmOYICKjkojIhPTAfNDZGNYruJMukEeB2JyxSz+J9jhjPe//9x4JznpCzm/JzCHFO9CfONjHIcUqLa9qxqhmBFpr1U5J7vRir4ch7v8TGtGbcR3833HTUA7EEMu/Ca48XVfGNDmySQs8zgGpj1yzf/lBGbiAzTSp7Zp+ANLu+R3NjeiDUYQbgf3vcpoHL44duk4dzhD+ofFD75PF1SMTluWbeLCSENH9io2pxVDj3I5VhlNxHdbqY1WXb+sDBVr4niIGzQiKqVOV33ghyRpzVJFZ7SaQG7VR/mLL3UnvJuapLYtUV9+/7Si/CHl7m8NntPMvx1nM/Z4t/BN8Z5cdhPn2PLxp9f5VCmCqLlCQDSv94cCTLlatiCTfF7axgE0u7+CWiOUNyyqg/vu0pjTwIA==
 ff5844cad7a27ee3eb5adad89ac8550949 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlxCG6EQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91YptD/9DG76IvubjzVsfX1UiQcV1mqWuSgz/idpeFCrc6Z1dyFB5UmbHKfAaZnrPBR7ly6bGD9+NZupB9A8QRxX92koiq0Hw2ywbwR5oWVrBaDiinIDLiTQTUCPnNMH0FSNrt4Kf9Gj4RqMufZvL+dR0pDYV0n6HP3aGOeTnowNhv0lUbw/Gx20YrcCU9uf3GbgRvMQiFNv9cTJAdQlH++98C8MVLfRU4ZxP11hI7sR8mp1q6ruJoozd0Cta67E6MyC/L2Rp3W89psvvY7DSTg9RwQwoS8I6U9iyQJ16Bb6UgZVV6jqQqOSxWUaPfKUhJLl2ENHH5f3rzoi3NH6jHuy5rq2v9XuvOpQ7LqSi1Ev0oq1xllZiyD4Zm69Z/Is0mxwqPskZGWR5Lh6Uq3Dh0zJW7O5M2m1IHdAYqffHpUr2NgEQVST4VDvO4fR2d7n6+ZNXYbZrpmQ1j4bpOZCEMqWXPfl4HY7a60hWa884mWxtVLGvhYycxnN8r1o5ouS0pAMAI6qEFFW1XFFN4eNDDWl83BkuDa32DTEthoyi15JM5jS7VPDYACdHE3IVqsTsZq7nn60uoFCGpdMcSqrD2mlUd9Z12x8NnCIrxKhlHLkq89OrQAcz8/0bbluGuzm3FHKb+8VQWr0MgkvOLTqqvOqn97oBdKqo0eyT0IPz8QeVYPbZfQ==
 b4b4ae0e9a6b8e579f7b0a693b8cf5c3b10 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlxUk3gQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91aT7EACaycWeal53ShxaNyTNOa5IPZ71+iyWA9xEh7hK6cDDirpItarWLRVWoWqBlWRBBs6uU4BxnpPSCLFkJLu6ts/5p4R6/0Z04Pasd6sFi14bCGslmPJFlwrpfFDpQvFR6xZAtv1xGb8n+rjpK+wfstjRgyf84zn4//0dOdylY5EUXOk4/3zcXKAzPgZHBRper+PlQ0ICgYHiKQUlyDWrFrdSEis6OqBa+PbxdmgzLYbhXi0bvS5XRWM9EVJZa+5ITEVOEGPClRcoA7SJE5DiapMYlwNnB3U6TEazJoj5yuvGhrJzj9lx7/jx9tzZ/mhdOVsSRiSCBu46B/E63fnUDqaMw8KKlFKBRuzKnqnByZD8fuD34YJ6A82hta56W4SJ4pusa/X2nAJn1QbRjESY4wN4FEaNdYiMbpgbG2uBDhmEowAyhXtiuQAPCUra5o42a+E+tAgV5uNUAal8vk0DcPRmzc4UntQiQGwxL0fsTEpMQtG5ryxWRmOIBq6aKGuLVELllPCwOh8UIGLlpAoEynlNi9qJNT6kHpSmwquiU6TG6R1dA/ckBK2H90hewtb/jwLlenGugpylLQ2U/NsDdoWRyHNrdB4eUJiWD/BBPXktZQJVja97Js+Vn44ctCkNjui/53xcBQfIYdHGLttIEq56v/yZiSviCcTUhBPRSEdoUg==
 ea21df312ec7159c5b3633096b6ecf68750b0dd 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlyQ7VYQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91aziD/4uI/Nr+UJgOri1zfa6ObXuMVO2FeadAolKemMDE/c4ddPUN2AwysZyJaOHmqj5VR0nf4a9CpTBc8Ciq9tfaFSWN6XFIJ2s3GPHhsnyhsPbF56c2bpl2W/csxor9eDGpv9TrQOK0qgI4wGxSQVFW0uUgHtZ5Yd6JWupHuyDfWopJf3oonissKI9ykRLeZEQ3sPIP6vTWMM3pdavAmDii3qKVEaCEGWmXgnM/vfBJ/tA1U5LSXpxwkJB7Pi/6Xc6OnGHWmCpsA4L6TSRkoyho4a6tLUA1Qlqm6sMxJjXAer8dmDLpmXL7gF3JhZgkiX74i2zDZnM4i42E6EhO52l3uorF5gtsw85dY20MSoBOmn5bM7k40TCA+vriNZJgmDrTYgY3B00mNysioEuSpDkILPJIV4U9LTazsxR49h3/mH2D1Sdxu6YtCIPE8ggThmveW/dZQy6W1xLfS66pFmDvq8ND0WjDa/Fi9dmjMcQtzA9CZL8AMlSc2aLJs++KjCuN+t6tn/tLhLz1nHaSitqgsIoJmBWb00QjOilnAQq7H8gUpUqMdLyEeL2B9HfJobQx6A8Op2xohjI7qD5gLGAxh+QMmuUmf7wx1h2UuQvrNW5di7S3k3nxfhm87Gkth3j0M/aMy0P6irPOKcKns55r6eOzItC+ezQayXc4A10F+x6Ew==
 a8d9ed864754837a185a642170cde24392f9abf 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAly3aLkQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91bpXD/0Qdx3lNv6230rl369PnGM7o56BFywJtGtQ0FjBj81/Q6IKNJkAus/FXA02MevAxnKhyCMPHbiWQn4cn+Fpt9Y7FOFl3MTdoY5v4rGDAbAaJsjyK3BNqSwWD1uFaOnFDzA/112MJ6nDciVaOzeD7qakMj8zdVhvyEfFszN7f7xT1JyGc+cOWfbvcIv/IXWZNrSZC0EzcZspfwxYQwFscgDL3AHeKeYqihJ6vgWxgEg4V8ZnJ6roJeERTp2wwvIj/pKSEpgzfLQfHiEwvH9MKMaJHGx4huzWJxYX2DB83LaK7cgkKqzyQ+z8rsb27oFPMVgb1Kg78+6sRujFdkahFWYYGPT6sFBDWkRQ/J7DRnBzHH2wbBoyNkApmLEfaRGJpxX8wojPFGJkNr6GF12uF7E+djsuE8ZL7l4p2YD33NBSzcEjNTlgruRauj/7SoSC3BgDlrqCypCkNgn5nDDjvf6oJx16qGqZsglHJOl0S2LRiGaMQTpBhpDWAyVIAQBRW/vF1IRnNJaQ+dX7M9VqlVsXnfh8WD+FPKDgpiSLO8hIuvlYlcrtU9rXyWu1njKvCs744G836k4SNBoi+y6bi6XbmU0Uv0GSCLyj1BIsqglfXuac0QHlz5RNmS6LVf7z13ZIn/ePXehYoKHu+PNDmbVGGwAVoZP4HLEqonD3SVpVcQ==
+e479ef7c9639be0029f00e6a722b96dcc05fee 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlzJ5QYQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91U0QD/4xQ00Suo+XNM/2v01NEALJA8pFxSaUcz1fBVQDwIQbApAHbjVDgIShuFlAXu7Jf582+C5wJu0J8L5Rb+Q9WJuM9sM+6cxUWclT3D3gB326LuQg86y5MYbzmwsSCOnBdRn/MY18on2XTa8t4Mxf0jAaHPUXEadmuwkOw4ds62eUD81lkakGoxgXrD1GUhAlGItNPOb0rp2XFj7i+LvazMX2mWOEXMXA5KPQrOvLsKnoESiPfONXumBfZNVSxVA7fJ3Vl1+PldBax+w9LQMgVGo+BkqPt7i+lPTcnlh2Nbf8y3zERTcItFBzrBxmuG6pINfNpZY/fi+9VL7mpMYlzlxs7VcLF8bVnpYpxpHfDR4hPjP0sq6+/nSSGUfzQXmfGHq0ZdoVGSzrDEv8UzYE9ehWUhHNE+sIU3MpwjC+WiW2YhYzPYN2KOlfSog3LuWLAcn3ZghWg1S4crsPt9CeE0vKxkNWNz9dzvhbniW7VGorXJKFCJzMu6pGaP/UjwpHxR+C6J1MGUW2TQwdIUyhPA8HfHJSVbifFJV+1CYEDcqRcFETpxm4YNrLJNL/Ns7zoWmdmEUXT1NEnK1r3Pe2Xi1o56FHGPffOWASmqFnF/coZCq6b4vmBWK/n8mI/JF1yxltfwacaY+1pEor92ztK34Lme1A+R7zyObGYNDcWiGZgA==

.hgtags

0 +1 0

              d40cc5aacc31ed673d9b5b24f98bee78c283062c 0.4f
 c590d34bf61e2ea12c71738e5a746cd74586157 0.4e
 eca4cfa8aad5fce9a04f7d8acadcd0452e2f34e 0.4d
              b4d0c3786ad3e47beacf8412157326a32b6d25a4 0.4c
              f40273b0ad7b3a6d3012fd37736d0611f41ecf54 0.5
 a28dfe59f8fab54a5118c5be4f40da34a53cdb7 0.5b
 e0fdbc57a0be78f0e817fd1d170a3615cd35da 0.6
 ccf3de52989b14c3d84e1097f59e39a992e00bd 0.6b
              eac9c8efcd9bd8244e72fb6821f769f450457a32 0.6c
 c049974485125e1f9357f6bbe9c1b548a64c3 0.7
 a56574f329a368d645853e0f9e09472aee62349 0.8
 a03cff2b0f5d30281e6addefe96b993582f2eac 0.8.1
 fb62a3a673d5322f6274a44ba6456e5e4b3b37 0.9
 be3001847cb18a23c403439d9e7d0ace30804e9 0.9.1
 a957364b1b89c150f2d0e60a99befe0ee08bd3 0.9.2
 c29bfec36d5540fbe1c976810aefecfd1d2 0.9.3
              fb4b6d5fe100b0886f8bc3d6731ec0e5ed5c4694 0.9.4
              23889160905a1b09fffe1c07378e9fc1827606eb 0.9.5
              bae2e9c838e90a393bae3973a7850280413e091a 1.0
              d5cbbe2c49cee22a9fbeb9ea41daa0ac4e26b846 1.0.1
              d2375bbee6d47e62ba8e415c86e83a465dc4dce9 1.0.2
 a67430f92f15ea5159c26b09ec4839a0c549a26 1.1
 e510d433969e277b1863c317b674cbee2065 1.1.1
 a4eb81fb4f4742451591489e2797dc47903277 1.1.2
 efa41037e280d08cfb07c09ad485df30fb0ea8 1.2
              02981000012e3adf40c4849bd7b3d5618f9ce82d 1.2.1
 d40e7c885fa6e95f89134809b3ec7bdbca34b 1.3
 ef6c14a1e8e83a31226f5881b7fe6095bbfa6f6 1.3.1
 ec469f9b556f11819937cf68ee53f2be927ebf 1.4
 d7ea6fe3aa4ab9ec274a68846779153789de9 1.4.1
 a0b14a68621f6990c54fdba0083f6f20935bf 1.4.2
 aa619c4c2c09907034d9824ebb1dd0e878206eb 1.4.3
              ff2704a8ded37fbebd8b6eb5ec733731d725da8a 1.5
 b01dab594167bc0dd33331dbaa6dca3dca1b3aa 1.5.1
 f725929f0c48c5fb3b90c071fc3066012456ca 1.5.2
              fdcf80f26604f233dc4d8f0a5ef9d7470e317e8a 1.5.3
 fe2629c6fd0c74c90bd066e77387c2b02e8437 1.5.4
              f786fc4b8764cd2a5526d259cf2f94d8a66924d9 1.6
              bf1774d95bde614af3956d92b20e2a0c68c5fec7 1.6.1
              c00f03a4982e467fb6b6bd45908767db6df4771d 1.6.2
              ff5cec76b1c5b6be9c3bb923aae8c3c6d079d6b9 1.6.3
 d8bff78c96fe7e33237b257558ee97290048a4 1.6.4
 b9e0f96c7bc788e5667c146a58a9440a55 1.7
              4438875ec01bd0fc32be92b0872eb6daeed4d44f 1.7.1
 aff4f144ad356311318b0011df0bb21f2c97429 1.7.2
              e3bf16703e2601de99e563cdb3a5d50b64e6d320 1.7.3
              a6c855c32ea081da3c3b8ff628f1847ff271482f 1.7.4
 b2155623ee2559caf288fd333f30475966c4525 1.7.5
              2616325766e3504c8ae7c84bd15ee610901fe91d 1.8
              aa1f3be38ab127280761889d2dca906ca465b5f4 1.8.1
              b032bec2c0a651ca0ddecb65714bfe6770f67d70 1.8.2
 cb1e95676ad089596bd81d0937cad37d6e3b7fb 1.8.3
 af5d9f6b22387913e1d11350fb8cb7c1487dd 1.8.4
              de9eb6b1da4fc522b1cab16d86ca166204c24f25 1.9
 a43e23b8c55b4566b8200bf69fe2158485a2634 1.9.1
              d629f1e89021103f1753addcef6b310e4435b184 1.9.2
 a9292e430e35766c552066ed3e87c557b803b 1.9.3
              384082750f2c51dc917d85a7145748330fa6ef4d 2.0-rc
 d55b481ddfcc1dacb445179649e24ca861d 2.0
 dbd1cef0c2f9f8bcf4ea303238105f716bda3 2.0.1
              6344043924497cd06d781d9014c66802285072e4 2.0.2
              db33555eafeaf9df1e18950e29439eaa706d399b 2.1-rc
 aa5b51f310fb3befd26bed99c02267f5c12c734 2.1
 e2cd303ecf8ca7c7eeebd785c34e5ed6b0f4a4 2.1.1
              b9bd95e61b49c221c4cca24e6da7c946fc02f992 2.1.2
              d9e2f09d5488c395ae9ddbb320ceacd24757e055 2.2-rc
 b3d087909e3c3ae44761efecdde8f319ef3 2.2
 de86462c5a9f42a3ad0f5e90ce5b1d221d25 2.2.1
 a358df5bbbe404ca25730c9c459b34263441dc 2.2.2
              b013baa3898e117959984fc64c29d8c784d2f28b 2.2.3
              a06e2681dd1786e2354d84a5fa9c1c88dd4fa3e0 2.3-rc
 f5094bb3f423fc799e471aac2aee81a7ce57a0b 2.3
 ae4ddb654eb2d5fd35bff358c738414432 2.3.1
              b3f0f9a39c4e1d0250048cd803ab03542d6f140a 2.3.2
              d118a4f4fd16d9b558ec3f3e87bfee772861d2b7 2.4-rc
 ad823b5d58c68903a6153a25e3fb4ed25239d 2.4
 c10cf8191469e7c3c8844922e17e71a176cb7cb 2.4.1
              a4765077b65e6ae29ba42bab7834717b5072d5ba 2.4.2
              f5fbe15ca7449f2c9a3cf817c86d0ae68b307214 2.5-rc
              a6088c05e43a8aee0472ca3a4f6f8d7dd914ebbf 2.5
 d4df752e61fe7ae4f3682e0a0008573b0402 2.5.1
 b7175377babacce80a6c1e12366d8032a6d4340 2.5.2
 c922c1b5145dab8baefefb0437d363b6a6c21c 2.5.3
 a7bd2dccd44ed571afe7424cd7f95594f27c092 2.5.4
 cd385856d98bacb2c3086f8897bc660c2beea 2.6-rc
 f785b38af38d2fca6b8f3db56b8007a84cd73a 2.6
              ddc7a6be20212d18f3e27d9d7e6f079a66d96f21 2.6.1
              cceaf7af4c9e9e6fa2dbfdcfe9856c5da69c4ffd 2.6.2
 acc6e37a650f0fae37872e733382ac1c0c 2.6.3
              f0d7721d7322dcfb5af33599c2543f27335334bb 2.7-rc
              f37b5a17e6a0ee17afde2cdde5393dd74715fb58 2.7
 a558f81dc73afeab4d7be63617392b130117f 2.7.1
              e7fa36d2ad3a7944a52dca126458d6f482db3524 2.7.2
 f2d8f2421314b1ddead8f7d0c91009358994 2.8-rc
              d825e4025e39d1c39db943cdc89818abd0a87c27 2.8
 e04a06467e2969c0cc6501335be0406d46ef0 2.8.1
              ca387377df7a3a67dbb90b6336b781cdadc3ef41 2.8.2
              8862469e16f9236208581b20de5f96bd13cc039d 2.9-rc
 cec5134e9c4bceab6a00c60f52a4f80677a78f2 2.9
              b96cb15ec9e04d8ac5ee08b34fcbbe4200588965 2.9.1
 f83fc5cfe715d292069ee8417c83804f6c6c1e4 2.9.2
 f55b251224f16508dd1311452db7780dafe2b 3.0-rc
 ac506c6ababe86985b932f4948837c0891b5 3.0
 c80ee5b3cb3684fa8edc61501b3506d02eb10 3.0.1
 d8cd3d0e83c7336c0cb45a9f88638363f993848 3.0.2
 c36dc6cd61a0e1b563f1d51e55bdf4dacf12162 3.1-rc
 e49892020336491cdc6945885c4de26ffa8b 3.1
 dc91146f35369949ea56b40172308158b59063a 3.1.1
              f768c888aaa68d12dd7f509dcc7f01c9584357d0 3.1.2
 f8d16af8cae246fa5a48e723d48d58b015aed94 3.2-rc
              ced632394371a36953ce4d394f86278ae51a2aae 3.2
 c58303fb0ec020907af28b9e486be299ba043 3.2.1
              902554884335e5ca3661d63be9978eb4aec3f68a 3.2.2
 dad422ecc5adb63d9fa649eeb8e05a5f9bc4900 3.2.3
 a3a71d75396f5d4cf6935ae7d9ba5407a547 3.2.4
              db8e3f7948b1fdeb9ad12d448fc3525759908b9f 3.3-rc
              fbdd5195528fae4f41feebc1838215c110b25d6a 3.3
 b4ed033390bf6e2879c8f5c28c84e1ee3b87231 3.3.1
 a92bbd02e5e3a625e0820389b47786b02b2cea 3.3.2
 e2e9a0750f91a6fe0ad88e4de34f8efefdcab08 3.3.3
              e89f909edffad558b56f4affa8239e4832f88de0 3.4-rc
 cc6036bca532e06681c5a8fa37efaa812de67b5 3.4
              ed18f4acf435a2824c6f49fba40f42b9df5da7ad 3.4.1
 cd0ddac49c1125b2e013aa2ff18ecbd4dd954 3.4.2
 a38d44ba093bd1d1ecfd34119e94056030278b 3.5-rc
 aa1c313b05b1a85f8ffa1120d51579ddf6bf24 3.5
 a45e49a6bed023deb229102a8903234d18054d3 3.5.1
 a466b9f9792e3ad7ae3fc6c43c3ff2e136b718d 3.5.2
              b66e3ca0b90c3095ea28dfd39aa24247bebf5c20 3.6-rc
 dd34f2e7272be9e3b2a5a83cd0d20be44293f4 3.6
 aa5083cbebbe7575c88f3402ab377539b484897 3.6.1
 d437a0f3355834a9485bbbeb30a52a052c98f19 3.6.2
              ea389970c08449440587712117f178d33bab3f1e 3.6.3
 bdc8965720ca4061f8f8d806563cfc7cdb62e 3.7-rc
              2408645de650d8a29a6ce9e7dce601d8dd0d1474 3.7
              b698abf971e7377d9b7ec7fc8c52df45255b0329 3.7.1
              d493d64757eb45ada99fcb3693e479a51b7782da 3.7.2
              ae279d4a19e9683214cbd1fe8298cf0b50571432 3.7.3
 eedf2c450aee58b1a90b0e826f47c5da64 3.8-rc
              f85de28eae32e7d3064b1a1321309071bbaaa069 3.8
              a56296f55a5e1038ea5016dace2076b693c28a56 3.8.1
              aaabed77791a75968a12b8c43ad263631a23ee81 3.8.2
              a9764ab80e11bcf6a37255db7dd079011f767c6c 3.8.3
 a5d605b8683a292bb89aea11f37a81b06ac016 3.8.4
 bb4f9d3a47a6e83c2b414d58811ed38f503c2 3.9-rc
 f84e68dbb9bd026f0f3a974ce4bdb93686 3.9
              ccd436f7db6d5d7b9af89715179b911d031d44f1 3.9.1
 e68974eb5c63ccb03f794d8b57339a80c4 3.9.2
 c415874f6ac653efc1099dec9c9150e90f 4.0-rc
              eab27446995210c334c3d06f1a659e3b9b5da769 4.0
              b3b1ae98f6a0e14c1e1ba806a6c18e193b6dae5c 4.0.1
              e69874dc1f4e142746ff3df91e678a09c6fc208c 4.0.2
              a1dd2c0c479e0550040542e392e87bc91262517e 4.1-rc
              e1526da1e6d84e03146151c9b6e6950fe9a83d7d 4.1
 b624d27e3917d978af56d6ad59331e0464a 4.1.1
              ed5b25874d998ababb181a939dd37a16ea644435 4.1.2
 eaf9539499a1b8be259ffe7ada787d07857f80 4.1.3
 e788321cc4ae9975b7f0c54c849f36d82182b 4.2-rc
              bb96d4a497432722623ae60d9bc734a1e360179e 4.2
              c850f0ed54c1d42f9aa079ad528f8127e5775217 4.2.1
 c49ed51a698ec016d2b4c6b44ca3c3f73cc788 4.2.2
 ebaed4e315f63157bd157d6ce553c7ab73 4.3-rc
 af8622863796a0027566f6b646e10d522c4c 4.3
 c91326b23954e6e1c6960d0239511f9530258 4.2.3
 fee7f7d2da04226914c2258cc2884dc27384fd7 4.3.1
 f72c7b70acfdaf56ab35360584d7845827 4.3.2
 f427b57bf9019c6dc3750baa539dc22c1be50f6 4.3.3
 e2454b60e5936f5e77498cab2648db469504487 4.4-rc
 ccb43d4cf01d013ae05917ec4f305509f851b2d 4.4
              cabc840ffdee8a72f3689fb77dd74d04fdc2bc04 4.4.1
              a92b9f8e11ba330614cdfd6af0e03b15c1ff3797 4.4.2
 b6df1b5adbdf647cf5c6675b40575e1b197c60 4.5-rc
              d334afc585e29577f271c5eda03378736a16ca6b 4.5
 aadf7a3264b03c8b09efce715bc41e6ab4a9b 4.5.1
 bba684efde7f45add05f737952093bb2aa07155 4.5.2
 de7bd407251af2bc98e5b809c8598ee95830daf 4.5.3
              ed5448edcbfa747b9154099e18630e49024fd47b 4.6rc0
 ec874717d8a93b19e0d50628443e0ee5efab3a9 4.6rc1
 cac550aea66d19c601e45efd1b7bd08d7c40 4.6
 c5ced5276d6e7d54f7c3dadf5247b7ee98ec79c 4.6.1
 b63a6743010dfdbf8a8154186e119949bdaa1cc 4.6.2
              e90130af47ce8dd53a3109aed9d15876b3e7dee8 4.7rc0
 ac6a72308a215e6086fbced347ec10aa963b0a 4.7
              ede3bf31fe63677fdf5bd8db687977d4e3d792ed 4.7.1
 cb1a79010ac50c58cd84e6f50c4556bf2a4c 4.7.2
 ec6f1320df26f3133ec40f3de866ea0695fd7 4.8rc0
              a91a2837150bdcb27ae76b3646e6c93cd6a15904 4.8
 c8c54cf97256f4468da2eb4dbee24f7f3888e71 4.8.1
 f092b2cd9691e2a55d198f717b231af9be6f9 4.8.2
 ff5844cad7a27ee3eb5adad89ac8550949 4.9rc0
 b4b4ae0e9a6b8e579f7b0a693b8cf5c3b10 4.9
 ea21df312ec7159c5b3633096b6ecf68750b0dd 4.9.1
 a8d9ed864754837a185a642170cde24392f9abf 5.0rc0
+e479ef7c9639be0029f00e6a722b96dcc05fee 5.0

contrib/Makefile.python

0 +1 -1

-             PYTHONVER=2.7.14
+             PYTHONVER=2.7.16
              PYTHONNAME=python-
              PREFIX=$(HOME)/bin/prefix-$(PYTHONNAME)$(PYTHONVER)
              SYMLINKDIR=$(HOME)/bin
              help:
              	@echo
              	@echo 'Make a custom installation of a Python version'
              	@echo
              	@echo 'Common make parameters:'
              	@echo '  PYTHONVER=...    [$(PYTHONVER)]'
              	@echo '  PREFIX=...       [$(PREFIX)]'
              	@echo '  SYMLINKDIR=...   [$(SYMLINKDIR) creating $(PYTHONNAME)$(PYTHONVER)]'
              	@echo
              	@echo 'Common make targets:'
              	@echo '  python    - install Python $$PYTHONVER in $$PREFIX'
              	@echo '  symlink   - create a $$SYMLINKDIR/$(PYTHONNAME)$$PYTHONVER symlink'
              	@echo
              	@echo 'Example: create a temporary Python installation:'
              	@echo '  $$ make -f Makefile.python python PYTHONVER=${PYTHONVER} PREFIX=/tmp/p27'
              	@echo '  $$ /tmp/p27/bin/python -V'
              	@echo '  Python 2.7'
              	@echo
              	@echo 'Some external libraries are required for building Python: zlib bzip2 openssl.'
              	@echo 'Make sure their development packages are installed systemwide.'
              # fedora: yum install zlib-devel bzip2-devel openssl-devel
              # debian: apt-get install zlib1g-dev libbz2-dev libssl-dev
              	@echo
              	@echo 'To build a nice collection of interesting Python versions:'
              	@echo '  $$ for v in 2.{6{,.1,.2,.9},7{,.8,.10}}; do'
              	@echo '    make -f Makefile.python symlink PYTHONVER=$$v || break; done'
              	@echo 'To run a Mercurial test on all these Python versions:'
              	@echo '  $$ for py in `cd ~/bin && ls $(PYTHONNAME)2.*`; do'
              	@echo '    echo $$py; $$py run-tests.py test-http.t; echo; done'
              	@echo
              export LANGUAGE=C
              export LC_ALL=C
              python: $(PREFIX)/bin/python docutils
              	printf 'import sys, zlib, bz2, docutils, ssl' | $(PREFIX)/bin/python
              PYTHON_SRCDIR=Python-$(PYTHONVER)
              PYTHON_SRCFILE=$(PYTHON_SRCDIR).tgz
              $(PREFIX)/bin/python:
              	[ -f $(PYTHON_SRCFILE) ] || wget http://www.python.org/ftp/python/$(PYTHONVER)/$(PYTHON_SRCFILE) || curl -OL http://www.python.org/ftp/python/$(PYTHONVER)/$(PYTHON_SRCFILE) || [ -f $(PYTHON_SRCFILE) ]
              	rm -rf $(PYTHON_SRCDIR)
              	tar xf $(PYTHON_SRCFILE)
              	# Debian/Ubuntu disables SSLv2,3 the hard way, disable it on old Pythons too
              	-sed -i 's,self.*SSLv[23]_method(),0;//\0,g' $(PYTHON_SRCDIR)/Modules/_ssl.c
              	# Find multiarch system libraries on Ubuntu and disable fortify error when setting argv
              	LDFLAGS="-L/usr/lib/`dpkg-architecture -qDEB_HOST_MULTIARCH`"; \
              	BASECFLAGS=-U_FORTIFY_SOURCE; \
              	export LDFLAGS BASECFLAGS; \
              	cd $(PYTHON_SRCDIR) && ./configure --prefix=$(PREFIX) && make all SVNVERSION=pwd && make install
              	printf 'import sys, zlib, bz2, ssl' | $(PREFIX)/bin/python
              	rm -rf $(PYTHON_SRCDIR)
              DOCUTILSVER=0.12
              DOCUTILS_SRCDIR=docutils-$(DOCUTILSVER)
              DOCUTILS_SRCFILE=$(DOCUTILS_SRCDIR).tar.gz
              docutils: $(PREFIX)/bin/python
              	@$(PREFIX)/bin/python -c 'import docutils' || ( set -ex; \
              	[ -f $(DOCUTILS_SRCFILE) ] || wget http://downloads.sourceforge.net/project/docutils/docutils/$(DOCUTILSVER)/$(DOCUTILS_SRCFILE) || [ -f $(DOCUTILS_SRCFILE) ]; \
              	rm -rf $(DOCUTILS_SRCDIR); \
              	tar xf $(DOCUTILS_SRCFILE); \
              	cd $(DOCUTILS_SRCDIR) && $(PREFIX)/bin/python setup.py install --prefix=$(PREFIX); \
              	$(PREFIX)/bin/python -c 'import docutils'; \
              	rm -rf $(DOCUTILS_SRCDIR); )
              symlink: python $(SYMLINKDIR)
              	ln -sf $(PREFIX)/bin/python $(SYMLINKDIR)/$(PYTHONNAME)$(PYTHONVER)
              .PHONY: help python docutils symlink

contrib/packaging/buildrpm

0 +2 -2

              #!/bin/bash -e
              #
              # Build a Mercurial RPM from the current repo
              #
              # Tested on
              # - Fedora 20
              # - CentOS 5
              # - centOS 6
              . $(dirname $0)/packagelib.sh
              BUILD=1
              RPMBUILDDIR="$PWD/rpmbuild"
              while [ "$1" ]; do
                  case "$1" in
                  --prepare )
                      shift
                      BUILD=
                      ;;
                  --withpython | --with-python)
                      shift
-                     PYTHONVER=2.7.14
-                     PYTHONMD5=cee2e4b33ad3750da77b2e85f2f8b724
+                     PYTHONVER=2.7.16
+                     PYTHONMD5=f1a2ace631068444831d01485466ece0
                      ;;
                  --rpmbuilddir )
                      shift
                      RPMBUILDDIR="$1"
                      shift
                      ;;
                  * )
                      echo "Invalid parameter $1!" 1>&2
                      exit 1
                      ;;
                  esac
              done
              cd "`dirname $0`/../.."
              specfile=$PWD/contrib/packaging/mercurial.spec
              if [ ! -f $specfile ]; then
                  echo "Cannot find $specfile!" 1>&2
                  exit 1
              fi
              if [ ! -d .hg ]; then
                  echo 'You are not inside a Mercurial repository!' 1>&2
                  exit 1
              fi
              gethgversion
              if [ -z "$type" ] ; then
                 release=1
              else
                  release=0.9_$type
              fi
              if [ -n "$distance" ] ; then
                  release=$release+${distance}_${node}
              fi
              if [ "$PYTHONVER" ]; then
                  release=$release+$PYTHONVER
                  RPMPYTHONVER=$PYTHONVER
              else
                  RPMPYTHONVER=%{nil}
              fi
              mkdir -p $RPMBUILDDIR/{SOURCES,BUILD,SRPMS,RPMS}
              $HG archive -t tgz $RPMBUILDDIR/SOURCES/mercurial-$version-$release.tar.gz
              if [ "$PYTHONVER" ]; then
              (
                  mkdir -p build
                  cd build
                  PYTHON_SRCFILE=Python-$PYTHONVER.tgz
                  [ -f $PYTHON_SRCFILE ] || curl -Lo $PYTHON_SRCFILE http://www.python.org/ftp/python/$PYTHONVER/$PYTHON_SRCFILE
                  if [ "$PYTHONMD5" ]; then
                      echo "$PYTHONMD5 $PYTHON_SRCFILE" | md5sum -w -c
                  fi
                  ln -f $PYTHON_SRCFILE $RPMBUILDDIR/SOURCES/$PYTHON_SRCFILE
                  DOCUTILSVER=`sed -ne "s/^%global docutilsname docutils-//p" $specfile`
                  DOCUTILS_SRCFILE=docutils-$DOCUTILSVER.tar.gz
                  [ -f $DOCUTILS_SRCFILE ] || curl -Lo $DOCUTILS_SRCFILE http://downloads.sourceforge.net/project/docutils/docutils/$DOCUTILSVER/$DOCUTILS_SRCFILE
                  DOCUTILSMD5=`sed -ne "s/^%global docutilsmd5 //p" $specfile`
                  if [ "$DOCUTILSMD5" ]; then
                      echo "$DOCUTILSMD5 $DOCUTILS_SRCFILE" | md5sum -w -c
                  fi
                  ln -f $DOCUTILS_SRCFILE $RPMBUILDDIR/SOURCES/$DOCUTILS_SRCFILE
              )
              fi
              mkdir -p $RPMBUILDDIR/SPECS
              rpmspec=$RPMBUILDDIR/SPECS/mercurial.spec
              sed -e "s,^Version:.*,Version: $version," \
                  -e "s,^Release:.*,Release: $release," \
                  $specfile > $rpmspec
              echo >> $rpmspec
              echo "%changelog" >> $rpmspec
              if echo $version | grep '+' > /dev/null 2>&1; then
                  latesttag="`echo $version | sed -e 's/+.*//'`"
                  $HG log -r .:"$latesttag" -fM \
                      --template '{date|hgdate}\t{author}\t{desc|firstline}\n' | python -c '
              import sys, time
              def datestr(date, format):
                  return time.strftime(format, time.gmtime(float(date[0]) - date[1]))
              changelog = []
              for l in sys.stdin.readlines():
                  tok = l.split("\t")
                  hgdate = tuple(int(v) for v in tok[0].split())
                  changelog.append((datestr(hgdate, "%F"), tok[1], hgdate, tok[2]))
              prevtitle = ""
              for l in sorted(changelog, reverse=True):
                  title = "* %s %s" % (datestr(l[2], "%a %b %d %Y"), l[1])
                  if prevtitle != title:
                      prevtitle = title
                      print
                      print title
                  print "- %s" % l[3].strip()
              ' >> $rpmspec
              else
                  $HG log \
                       --template '{date|hgdate}\t{author}\t{desc|firstline}\n' \
                       .hgtags | python -c '
              import sys, time
              def datestr(date, format):
                  return time.strftime(format, time.gmtime(float(date[0]) - date[1]))
              for l in sys.stdin.readlines():
                  tok = l.split("\t")
                  hgdate = tuple(int(v) for v in tok[0].split())
                  print "* %s %s\n- %s" % (datestr(hgdate, "%a %b %d %Y"), tok[1], tok[2])
              ' >> $rpmspec
              fi
              sed -i \
                  -e "s/^%define withpython.*$/%define withpython $RPMPYTHONVER/" \
                  $rpmspec
              if [ "$BUILD" ]; then
                  rpmbuild --define "_topdir $RPMBUILDDIR" -ba $rpmspec --clean
                  if [ $? = 0 ]; then
                      echo
                      echo "Built packages for $version-$release:"
                      find $RPMBUILDDIR/*RPMS/ -type f -newer $rpmspec
                  fi
              else
                  echo "Prepared sources for $version-$release $rpmspec are in $RPMBUILDDIR/SOURCES/ - use like:"
                  echo "rpmbuild --define '_topdir $RPMBUILDDIR' -ba $rpmspec --clean"
              fi

contrib/packaging/inno/requirements.txt

0 +3 -3

              #
              # This file is autogenerated by pip-compile
              # To update, run:
              #
              #    pip-compile --generate-hashes contrib/packaging/inno/requirements.txt.in -o contrib/packaging/inno/requirements.txt
              #
              certifi==2018.11.29 \
                  --hash=sha256:47f9c83ef4c0c621eaef743f133f09fa8a74a9b75f037e8624f83bd1b6626cb7 \
                  --hash=sha256:993f830721089fef441cdfeb4b2c8c9df86f0c63239f06bd025a76a7daddb033 \
                  # via dulwich
              configparser==3.7.3 \
                  --hash=sha256:27594cf4fc279f321974061ac69164aaebd2749af962ac8686b20503ac0bcf2d \
                  --hash=sha256:9d51fe0a382f05b6b117c5e601fc219fede4a8c71703324af3f7d883aef476a3 \
                  # via entrypoints
              docutils==0.14 \
                  --hash=sha256:02aec4bd92ab067f6ff27a38a38a41173bf01bed8f89157768c1573f53e474a6 \
                  --hash=sha256:51e64ef2ebfb29cae1faa133b3710143496eca21c530f3f71424d77687764274 \
                  --hash=sha256:7a4bd47eaf6596e1295ecb11361139febe29b084a87bf005bf899f9a42edc3c6
              dulwich==0.19.11 \
                  --hash=sha256:afbe070f6899357e33f63f3f3696e601731fef66c64a489dea1bc9f539f4a725
              entrypoints==0.3 \
                  --hash=sha256:589f874b313739ad35be6e0cd7efde2a4e9b6fea91edcc34e58ecbb8dbe56d19 \
                  --hash=sha256:c70dd71abe5a8c85e55e12c19bd91ccfeec11a6e99044204511f9ed547d48451 \
                  # via keyring
-             keyring==18.0.0 \
-                 --hash=sha256:12833d2b05d2055e0e25931184af9cd6a738f320a2264853cabbd8a3a0f0b65d \
-                 --hash=sha256:ca33f5ccc542b9ffaa196ee9a33488069e5e7eac77d5b81969f8a3ce74d0230c
+             keyring==18.0.1 \
+                 --hash=sha256:67d6cc0132bd77922725fae9f18366bb314fd8f95ff4d323a4df41890a96a838 \
+                 --hash=sha256:7b29ebfcf8678c4da531b2478a912eea01e80007e5ddca9ee0c7038cb3489ec6
              pygments==2.3.1 \
                  --hash=sha256:5ffada19f6203563680669ee7f53b64dabbeb100eb51b61996085e99c03b284a \
                  --hash=sha256:e8218dd399a61674745138520d0d4cf2621d7e032439341bc3f647bff125818d
              pywin32-ctypes==0.2.0 \
                  --hash=sha256:24ffc3b341d457d48e8922352130cf2644024a4ff09762a2261fd34c36ee5942 \
                  --hash=sha256:9dc2d991b3479cc2df15930958b674a48a227d5361d413827a4cfd0b5876fc98 \
                  # via keyring
              urllib3==1.24.1 \
                  --hash=sha256:61bf29cada3fc2fbefad4fdf059ea4bd1b4a86d2b6d15e1c7c0b582b9752fe39 \
                  --hash=sha256:de9529817c93f27c8ccbfead6985011db27bd0ddfcdb2d86f3f663385c6a9c22 \
                  # via dulwich

hgext/narrow/narrowbundle2.py

0 +21 -1

              # narrowbundle2.py - bundle2 extensions for narrow repository support
              #
              # Copyright 2017 Google, Inc.
              #
              # This software may be used and distributed according to the terms of the
              # GNU General Public License version 2 or any later version.
              from __future__ import absolute_import
              import errno
              import struct
              from mercurial.i18n import _
              from mercurial.node import (
                  bin,
                  nullid,
              )
              from mercurial import (
                  bundle2,
                  changegroup,
                  error,
                  exchange,
                  localrepo,
                  narrowspec,
                  repair,
                  repository,
                  util,
                  wireprototypes,
              )
              from mercurial.utils import (
                  stringutil,
              )
-             _NARROWACL_SECTION = 'narrowhgacl'
+             _NARROWACL_SECTION = 'narrowacl'
              _CHANGESPECPART = 'narrow:changespec'
+             _RESSPECS = 'narrow:responsespec'
              _SPECPART = 'narrow:spec'
              _SPECPART_INCLUDE = 'include'
              _SPECPART_EXCLUDE = 'exclude'
              _KILLNODESIGNAL = 'KILL'
              _DONESIGNAL = 'DONE'
              _ELIDEDCSHEADER = '>20s20s20sl' # cset id, p1, p2, len(text)
              _ELIDEDMFHEADER = '>20s20s20s20sl' # manifest id, p1, p2, link id, len(text)
              _CSHEADERSIZE = struct.calcsize(_ELIDEDCSHEADER)
              _MFHEADERSIZE = struct.calcsize(_ELIDEDMFHEADER)
              # Serve a changegroup for a client with a narrow clone.
              def getbundlechangegrouppart_narrow(bundler, repo, source,
                                                  bundlecaps=None, b2caps=None, heads=None,
                                                  common=None, **kwargs):
                  assert repo.ui.configbool('experimental', 'narrowservebrokenellipses')
                  cgversions = b2caps.get('changegroup')
                  if cgversions:  # 3.1 and 3.2 ship with an empty value
                      cgversions = [v for v in cgversions
                                    if v in changegroup.supportedoutgoingversions(repo)]
                      if not cgversions:
                          raise ValueError(_('no common changegroup version'))
                      version = max(cgversions)
                  else:
                      raise ValueError(_("server does not advertise changegroup version,"
                                         " can't negotiate support for ellipsis nodes"))
                  include = sorted(filter(bool, kwargs.get(r'includepats', [])))
                  exclude = sorted(filter(bool, kwargs.get(r'excludepats', [])))
                  newmatch = narrowspec.match(repo.root, include=include, exclude=exclude)
                  depth = kwargs.get(r'depth', None)
                  if depth is not None:
                      depth = int(depth)
                      if depth < 1:
                          raise error.Abort(_('depth must be positive, got %d') % depth)
                  heads = set(heads or repo.heads())
                  common = set(common or [nullid])
                  oldinclude = sorted(filter(bool, kwargs.get(r'oldincludepats', [])))
                  oldexclude = sorted(filter(bool, kwargs.get(r'oldexcludepats', [])))
                  known = {bin(n) for n in kwargs.get(r'known', [])}
                  if known and (oldinclude != include or oldexclude != exclude):
                      # Steps:
                      # 1. Send kill for "$known & ::common"
                      #
                      # 2. Send changegroup for ::common
                      #
                      # 3. Proceed.
                      #
                      # In the future, we can send kills for only the specific
                      # nodes we know should go away or change shape, and then
                      # send a data stream that tells the client something like this:
                      #
                      # a) apply this changegroup
                      # b) apply nodes XXX, YYY, ZZZ that you already have
                      # c) goto a
                      #
                      # until they've built up the full new state.
                      # Convert to revnums and intersect with "common". The client should
                      # have made it a subset of "common" already, but let's be safe.
                      known = set(repo.revs("%ln & ::%ln", known, common))
                      # TODO: we could send only roots() of this set, and the
                      # list of nodes in common, and the client could work out
                      # what to strip, instead of us explicitly sending every
                      # single node.
                      deadrevs = known
                      def genkills():
                          for r in deadrevs:
                              yield _KILLNODESIGNAL
                              yield repo.changelog.node(r)
                          yield _DONESIGNAL
                      bundler.newpart(_CHANGESPECPART, data=genkills())
                      newvisit, newfull, newellipsis = exchange._computeellipsis(
                          repo, set(), common, known, newmatch)
                      if newvisit:
                          packer = changegroup.getbundler(version, repo,
                                                          matcher=newmatch,
                                                          ellipses=True,
                                                          shallow=depth is not None,
                                                          ellipsisroots=newellipsis,
                                                          fullnodes=newfull)
                          cgdata = packer.generate(common, newvisit, False, 'narrow_widen')
                          part = bundler.newpart('changegroup', data=cgdata)
                          part.addparam('version', version)
                          if 'treemanifest' in repo.requirements:
                              part.addparam('treemanifest', '1')
                  visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis(
                      repo, common, heads, set(), newmatch, depth=depth)
                  repo.ui.debug('Found %d relevant revs\n' % len(relevant_nodes))
                  if visitnodes:
                      packer = changegroup.getbundler(version, repo,
                                                      matcher=newmatch,
                                                      ellipses=True,
                                                      shallow=depth is not None,
                                                      ellipsisroots=ellipsisroots,
                                                      fullnodes=relevant_nodes)
                      cgdata = packer.generate(common, visitnodes, False, 'narrow_widen')
                      part = bundler.newpart('changegroup', data=cgdata)
                      part.addparam('version', version)
                      if 'treemanifest' in repo.requirements:
                          part.addparam('treemanifest', '1')
              @bundle2.parthandler(_SPECPART, (_SPECPART_INCLUDE, _SPECPART_EXCLUDE))
              def _handlechangespec_2(op, inpart):
+                 # XXX: This bundle2 handling is buggy and should be removed after hg5.2 is
+                 # released. New servers will send a mandatory bundle2 part named
+                 # 'Narrowspec' and will send specs as data instead of params.
+                 # Refer to issue5952 and 6019
                  includepats = set(inpart.params.get(_SPECPART_INCLUDE, '').splitlines())
                  excludepats = set(inpart.params.get(_SPECPART_EXCLUDE, '').splitlines())
                  narrowspec.validatepatterns(includepats)
                  narrowspec.validatepatterns(excludepats)
                  if not repository.NARROW_REQUIREMENT in op.repo.requirements:
                      op.repo.requirements.add(repository.NARROW_REQUIREMENT)
                      op.repo._writerequirements()
                  op.repo.setnarrowpats(includepats, excludepats)
                  narrowspec.copytoworkingcopy(op.repo)
+             @bundle2.parthandler(_RESSPECS)
+             def _handlenarrowspecs(op, inpart):
+                 data = inpart.read()
+                 inc, exc = data.split('\0')
+                 includepats = set(inc.splitlines())
+                 excludepats = set(exc.splitlines())
+                 narrowspec.validatepatterns(includepats)
+                 narrowspec.validatepatterns(excludepats)
+                 if repository.NARROW_REQUIREMENT not in op.repo.requirements:
+                     op.repo.requirements.add(repository.NARROW_REQUIREMENT)
+                     op.repo._writerequirements()
+                 op.repo.setnarrowpats(includepats, excludepats)
+                 narrowspec.copytoworkingcopy(op.repo)
              @bundle2.parthandler(_CHANGESPECPART)
              def _handlechangespec(op, inpart):
                  repo = op.repo
                  cl = repo.changelog
                  # changesets which need to be stripped entirely. either they're no longer
                  # needed in the new narrow spec, or the server is sending a replacement
                  # in the changegroup part.
                  clkills = set()
                  # A changespec part contains all the updates to ellipsis nodes
                  # that will happen as a result of widening or narrowing a
                  # repo. All the changes that this block encounters are ellipsis
                  # nodes or flags to kill an existing ellipsis.
                  chunksignal = changegroup.readexactly(inpart, 4)
                  while chunksignal != _DONESIGNAL:
                      if chunksignal == _KILLNODESIGNAL:
                          # a node used to be an ellipsis but isn't anymore
                          ck = changegroup.readexactly(inpart, 20)
                          if cl.hasnode(ck):
                              clkills.add(ck)
                      else:
                          raise error.Abort(
                              _('unexpected changespec node chunk type: %s') % chunksignal)
                      chunksignal = changegroup.readexactly(inpart, 4)
                  if clkills:
                      # preserve bookmarks that repair.strip() would otherwise strip
                      op._bookmarksbackup = repo._bookmarks
                      class dummybmstore(dict):
                          def applychanges(self, repo, tr, changes):
                              pass
                      localrepo.localrepository._bookmarks.set(repo, dummybmstore())
                      chgrpfile = repair.strip(op.ui, repo, list(clkills), backup=True,
                                               topic='widen')
                      if chgrpfile:
                          op._widen_uninterr = repo.ui.uninterruptible()
                          op._widen_uninterr.__enter__()
                          # presence of _widen_bundle attribute activates widen handler later
                          op._widen_bundle = chgrpfile
                  # Set the new narrowspec if we're widening. The setnewnarrowpats() method
                  # will currently always be there when using the core+narrowhg server, but
                  # other servers may include a changespec part even when not widening (e.g.
                  # because we're deepening a shallow repo).
                  if util.safehasattr(repo, 'setnewnarrowpats'):
                      repo.setnewnarrowpats()
              def handlechangegroup_widen(op, inpart):
                  """Changegroup exchange handler which restores temporarily-stripped nodes"""
                  # We saved a bundle with stripped node data we must now restore.
                  # This approach is based on mercurial/repair.py@6ee26a53c111.
                  repo = op.repo
                  ui = op.ui
                  chgrpfile = op._widen_bundle
                  del op._widen_bundle
                  vfs = repo.vfs
                  ui.note(_("adding branch\n"))
                  f = vfs.open(chgrpfile, "rb")
                  try:
                      gen = exchange.readbundle(ui, f, chgrpfile, vfs)
                      if not ui.verbose:
                          # silence internal shuffling chatter
                          ui.pushbuffer()
                      if isinstance(gen, bundle2.unbundle20):
                          with repo.transaction('strip') as tr:
                              bundle2.processbundle(repo, gen, lambda: tr)
                      else:
                          gen.apply(repo, 'strip', 'bundle:' + vfs.join(chgrpfile), True)
                      if not ui.verbose:
                          ui.popbuffer()
                  finally:
                      f.close()
                  # remove undo files
                  for undovfs, undofile in repo.undofiles():
                      try:
                          undovfs.unlink(undofile)
                      except OSError as e:
                          if e.errno != errno.ENOENT:
                              ui.warn(_('error removing %s: %s\n') %
                                      (undovfs.join(undofile), stringutil.forcebytestr(e)))
                  # Remove partial backup only if there were no exceptions
                  op._widen_uninterr.__exit__(None, None, None)
                  vfs.unlink(chgrpfile)
              def setup():
                  """Enable narrow repo support in bundle2-related extension points."""
                  getbundleargs = wireprototypes.GETBUNDLE_ARGUMENTS
                  getbundleargs['narrow'] = 'boolean'
                  getbundleargs['depth'] = 'plain'
                  getbundleargs['oldincludepats'] = 'csv'
                  getbundleargs['oldexcludepats'] = 'csv'
                  getbundleargs['known'] = 'csv'
                  # Extend changegroup serving to handle requests from narrow clients.
                  origcgfn = exchange.getbundle2partsmapping['changegroup']
                  def wrappedcgfn(*args, **kwargs):
                      repo = args[1]
                      if repo.ui.has_section(_NARROWACL_SECTION):
                          kwargs = exchange.applynarrowacl(repo, kwargs)
                      if (kwargs.get(r'narrow', False) and
                          repo.ui.configbool('experimental', 'narrowservebrokenellipses')):
                          getbundlechangegrouppart_narrow(*args, **kwargs)
                      else:
                          origcgfn(*args, **kwargs)
                  exchange.getbundle2partsmapping['changegroup'] = wrappedcgfn
                  # Extend changegroup receiver so client can fixup after widen requests.
                  origcghandler = bundle2.parthandlermapping['changegroup']
                  def wrappedcghandler(op, inpart):
                      origcghandler(op, inpart)
                      if util.safehasattr(op, '_widen_bundle'):
                          handlechangegroup_widen(op, inpart)
                      if util.safehasattr(op, '_bookmarksbackup'):
                          localrepo.localrepository._bookmarks.set(op.repo,
                                                                   op._bookmarksbackup)
                          del op._bookmarksbackup
                  wrappedcghandler.params = origcghandler.params
                  bundle2.parthandlermapping['changegroup'] = wrappedcghandler

mercurial/context.py

0 +1 -1

              # context.py - changeset and file context objects for mercurial
              #
              # Copyright 2006, 2007 Matt Mackall <mpm@selenic.com>
              #
              # This software may be used and distributed according to the terms of the
              # GNU General Public License version 2 or any later version.
              from __future__ import absolute_import
              import errno
              import filecmp
              import os
              import stat
              from .i18n import _
              from .node import (
                  addednodeid,
                  hex,
                  modifiednodeid,
                  nullid,
                  nullrev,
                  short,
                  wdirfilenodeids,
                  wdirhex,
              )
              from . import (
                  dagop,
                  encoding,
                  error,
                  fileset,
                  match as matchmod,
                  obsolete as obsmod,
                  patch,
                  pathutil,
                  phases,
                  pycompat,
                  repoview,
                  scmutil,
                  sparse,
                  subrepo,
                  subrepoutil,
                  util,
              )
              from .utils import (
                  dateutil,
                  stringutil,
              )
              propertycache = util.propertycache
              class basectx(object):
                  """A basectx object represents the common logic for its children:
                  changectx: read-only context that is already present in the repo,
                  workingctx: a context that represents the working directory and can
                              be committed,
                  memctx: a context that represents changes in-memory and can also
                          be committed."""
                  def __init__(self, repo):
                      self._repo = repo
                  def __bytes__(self):
                      return short(self.node())
                  __str__ = encoding.strmethod(__bytes__)
                  def __repr__(self):
                      return r"<%s %s>" % (type(self).__name__, str(self))
                  def __eq__(self, other):
                      try:
                          return type(self) == type(other) and self._rev == other._rev
                      except AttributeError:
                          return False
                  def __ne__(self, other):
                      return not (self == other)
                  def __contains__(self, key):
                      return key in self._manifest
                  def __getitem__(self, key):
                      return self.filectx(key)
                  def __iter__(self):
                      return iter(self._manifest)
                  def _buildstatusmanifest(self, status):
                      """Builds a manifest that includes the given status results, if this is
                      a working copy context. For non-working copy contexts, it just returns
                      the normal manifest."""
                      return self.manifest()
                  def _matchstatus(self, other, match):
                      """This internal method provides a way for child objects to override the
                      match operator.
                      """
                      return match
                  def _buildstatus(self, other, s, match, listignored, listclean,
                                   listunknown):
                      """build a status with respect to another context"""
                      # Load earliest manifest first for caching reasons. More specifically,
                      # if you have revisions 1000 and 1001, 1001 is probably stored as a
                      # delta against 1000. Thus, if you read 1000 first, we'll reconstruct
                      # 1000 and cache it so that when you read 1001, we just need to apply a
                      # delta to what's in the cache. So that's one full reconstruction + one
                      # delta application.
                      mf2 = None
                      if self.rev() is not None and self.rev() < other.rev():
                          mf2 = self._buildstatusmanifest(s)
                      mf1 = other._buildstatusmanifest(s)
                      if mf2 is None:
                          mf2 = self._buildstatusmanifest(s)
                      modified, added = [], []
                      removed = []
                      clean = []
                      deleted, unknown, ignored = s.deleted, s.unknown, s.ignored
                      deletedset = set(deleted)
                      d = mf1.diff(mf2, match=match, clean=listclean)
                      for fn, value in d.iteritems():
                          if fn in deletedset:
                              continue
                          if value is None:
                              clean.append(fn)
                              continue
                          (node1, flag1), (node2, flag2) = value
                          if node1 is None:
                              added.append(fn)
                          elif node2 is None:
                              removed.append(fn)
                          elif flag1 != flag2:
                              modified.append(fn)
                          elif node2 not in wdirfilenodeids:
                              # When comparing files between two commits, we save time by
                              # not comparing the file contents when the nodeids differ.
                              # Note that this means we incorrectly report a reverted change
                              # to a file as a modification.
                              modified.append(fn)
                          elif self[fn].cmp(other[fn]):
                              modified.append(fn)
                          else:
                              clean.append(fn)
                      if removed:
                          # need to filter files if they are already reported as removed
                          unknown = [fn for fn in unknown if fn not in mf1 and
                                                             (not match or match(fn))]
                          ignored = [fn for fn in ignored if fn not in mf1 and
                                                             (not match or match(fn))]
                          # if they're deleted, don't report them as removed
                          removed = [fn for fn in removed if fn not in deletedset]
                      return scmutil.status(modified, added, removed, deleted, unknown,
                                            ignored, clean)
                  @propertycache
                  def substate(self):
                      return subrepoutil.state(self, self._repo.ui)
                  def subrev(self, subpath):
                      return self.substate[subpath][1]
                  def rev(self):
                      return self._rev
                  def node(self):
                      return self._node
                  def hex(self):
                      return hex(self.node())
                  def manifest(self):
                      return self._manifest
                  def manifestctx(self):
                      return self._manifestctx
                  def repo(self):
                      return self._repo
                  def phasestr(self):
                      return phases.phasenames[self.phase()]
                  def mutable(self):
                      return self.phase() > phases.public
                  def matchfileset(self, expr, badfn=None):
                      return fileset.match(self, expr, badfn=badfn)
                  def obsolete(self):
                      """True if the changeset is obsolete"""
                      return self.rev() in obsmod.getrevs(self._repo, 'obsolete')
                  def extinct(self):
                      """True if the changeset is extinct"""
                      return self.rev() in obsmod.getrevs(self._repo, 'extinct')
                  def orphan(self):
                      """True if the changeset is not obsolete, but its ancestor is"""
                      return self.rev() in obsmod.getrevs(self._repo, 'orphan')
                  def phasedivergent(self):
                      """True if the changeset tries to be a successor of a public changeset
                      Only non-public and non-obsolete changesets may be phase-divergent.
                      """
                      return self.rev() in obsmod.getrevs(self._repo, 'phasedivergent')
                  def contentdivergent(self):
                      """Is a successor of a changeset with multiple possible successor sets
                      Only non-public and non-obsolete changesets may be content-divergent.
                      """
                      return self.rev() in obsmod.getrevs(self._repo, 'contentdivergent')
                  def isunstable(self):
                      """True if the changeset is either orphan, phase-divergent or
                      content-divergent"""
                      return self.orphan() or self.phasedivergent() or self.contentdivergent()
                  def instabilities(self):
                      """return the list of instabilities affecting this changeset.
                      Instabilities are returned as strings. possible values are:
                      - orphan,
                      - phase-divergent,
                      - content-divergent.
                      """
                      instabilities = []
                      if self.orphan():
                          instabilities.append('orphan')
                      if self.phasedivergent():
                          instabilities.append('phase-divergent')
                      if self.contentdivergent():
                          instabilities.append('content-divergent')
                      return instabilities
                  def parents(self):
                      """return contexts for each parent changeset"""
                      return self._parents
                  def p1(self):
                      return self._parents[0]
                  def p2(self):
                      parents = self._parents
                      if len(parents) == 2:
                          return parents[1]
                      return self._repo[nullrev]
                  def _fileinfo(self, path):
                      if r'_manifest' in self.__dict__:
                          try:
                              return self._manifest[path], self._manifest.flags(path)
                          except KeyError:
                              raise error.ManifestLookupError(self._node, path,
                                                              _('not found in manifest'))
                      if r'_manifestdelta' in self.__dict__ or path in self.files():
                          if path in self._manifestdelta:
                              return (self._manifestdelta[path],
                                      self._manifestdelta.flags(path))
                      mfl = self._repo.manifestlog
                      try:
                          node, flag = mfl[self._changeset.manifest].find(path)
                      except KeyError:
                          raise error.ManifestLookupError(self._node, path,
                                                          _('not found in manifest'))
                      return node, flag
                  def filenode(self, path):
                      return self._fileinfo(path)[0]
                  def flags(self, path):
                      try:
                          return self._fileinfo(path)[1]
                      except error.LookupError:
                          return ''
                  def sub(self, path, allowcreate=True):
                      '''return a subrepo for the stored revision of path, never wdir()'''
                      return subrepo.subrepo(self, path, allowcreate=allowcreate)
                  def nullsub(self, path, pctx):
                      return subrepo.nullsubrepo(self, path, pctx)
                  def workingsub(self, path):
                      '''return a subrepo for the stored revision, or wdir if this is a wdir
                      context.
                      '''
                      return subrepo.subrepo(self, path, allowwdir=True)
                  def match(self, pats=None, include=None, exclude=None, default='glob',
                            listsubrepos=False, badfn=None):
                      r = self._repo
                      return matchmod.match(r.root, r.getcwd(), pats,
                                            include, exclude, default,
                                            auditor=r.nofsauditor, ctx=self,
                                            listsubrepos=listsubrepos, badfn=badfn)
                  def diff(self, ctx2=None, match=None, changes=None, opts=None,
                           losedatafn=None, pathfn=None, copy=None,
                           copysourcematch=None, hunksfilterfn=None):
                      """Returns a diff generator for the given contexts and matcher"""
                      if ctx2 is None:
                          ctx2 = self.p1()
                      if ctx2 is not None:
                          ctx2 = self._repo[ctx2]
                      return patch.diff(self._repo, ctx2, self, match=match, changes=changes,
                                        opts=opts, losedatafn=losedatafn, pathfn=pathfn,
                                        copy=copy, copysourcematch=copysourcematch,
                                        hunksfilterfn=hunksfilterfn)
                  def dirs(self):
                      return self._manifest.dirs()
                  def hasdir(self, dir):
                      return self._manifest.hasdir(dir)
                  def status(self, other=None, match=None, listignored=False,
                             listclean=False, listunknown=False, listsubrepos=False):
                      """return status of files between two nodes or node and working
                      directory.
                      If other is None, compare this node with working directory.
                      returns (modified, added, removed, deleted, unknown, ignored, clean)
                      """
                      ctx1 = self
                      ctx2 = self._repo[other]
                      # This next code block is, admittedly, fragile logic that tests for
                      # reversing the contexts and wouldn't need to exist if it weren't for
                      # the fast (and common) code path of comparing the working directory
                      # with its first parent.
                      #
                      # What we're aiming for here is the ability to call:
                      #
                      # workingctx.status(parentctx)
                      #
                      # If we always built the manifest for each context and compared those,
                      # then we'd be done. But the special case of the above call means we
                      # just copy the manifest of the parent.
                      reversed = False
                      if (not isinstance(ctx1, changectx)
                          and isinstance(ctx2, changectx)):
                          reversed = True
                          ctx1, ctx2 = ctx2, ctx1
                      match = self._repo.narrowmatch(match)
                      match = ctx2._matchstatus(ctx1, match)
                      r = scmutil.status([], [], [], [], [], [], [])
                      r = ctx2._buildstatus(ctx1, r, match, listignored, listclean,
                                            listunknown)
                      if reversed:
                          # Reverse added and removed. Clear deleted, unknown and ignored as
                          # these make no sense to reverse.
                          r = scmutil.status(r.modified, r.removed, r.added, [], [], [],
                                             r.clean)
                      if listsubrepos:
                          for subpath, sub in scmutil.itersubrepos(ctx1, ctx2):
                              try:
                                  rev2 = ctx2.subrev(subpath)
                              except KeyError:
                                  # A subrepo that existed in node1 was deleted between
                                  # node1 and node2 (inclusive). Thus, ctx2's substate
                                  # won't contain that subpath. The best we can do ignore it.
                                  rev2 = None
                              submatch = matchmod.subdirmatcher(subpath, match)
                              s = sub.status(rev2, match=submatch, ignored=listignored,
                                             clean=listclean, unknown=listunknown,
                                             listsubrepos=True)
                              for rfiles, sfiles in zip(r, s):
                                  rfiles.extend("%s/%s" % (subpath, f) for f in sfiles)
                      for l in r:
                          l.sort()
                      return r
              class changectx(basectx):
                  """A changecontext object makes access to data related to a particular
                  changeset convenient. It represents a read-only context already present in
                  the repo."""
                  def __init__(self, repo, rev, node):
                      super(changectx, self).__init__(repo)
                      self._rev = rev
                      self._node = node
                  def __hash__(self):
                      try:
                          return hash(self._rev)
                      except AttributeError:
                          return id(self)
                  def __nonzero__(self):
                      return self._rev != nullrev
                  __bool__ = __nonzero__
                  @propertycache
                  def _changeset(self):
                      return self._repo.changelog.changelogrevision(self.rev())
                  @propertycache
                  def _manifest(self):
                      return self._manifestctx.read()
                  @property
                  def _manifestctx(self):
                      return self._repo.manifestlog[self._changeset.manifest]
                  @propertycache
                  def _manifestdelta(self):
                      return self._manifestctx.readdelta()
                  @propertycache
                  def _parents(self):
                      repo = self._repo
                      p1, p2 = repo.changelog.parentrevs(self._rev)
                      if p2 == nullrev:
                          return [repo[p1]]
                      return [repo[p1], repo[p2]]
                  def changeset(self):
                      c = self._changeset
                      return (
                          c.manifest,
                          c.user,
                          c.date,
                          c.files,
                          c.description,
                          c.extra,
                      )
                  def manifestnode(self):
                      return self._changeset.manifest
                  def user(self):
                      return self._changeset.user
                  def date(self):
                      return self._changeset.date
                  def files(self):
                      return self._changeset.files
                  @propertycache
                  def _copies(self):
                      source = self._repo.ui.config('experimental', 'copies.read-from')
                      p1copies = self._changeset.p1copies
                      p2copies = self._changeset.p2copies
                      # If config says to get copy metadata only from changeset, then return
                      # that, defaulting to {} if there was no copy metadata.
                      # In compatibility mode, we return copy data from the changeset if
                      # it was recorded there, and otherwise we fall back to getting it from
                      # the filelogs (below).
                      if (source == 'changeset-only' or
                          (source == 'compatibility' and p1copies is not None)):
                          return p1copies or {}, p2copies or {}
                      # Otherwise (config said to read only from filelog, or we are in
                      # compatiblity mode and there is not data in the changeset), we get
                      # the copy metadata from the filelogs.
                      p1copies = {}
                      p2copies = {}
                      p1 = self.p1()
                      p2 = self.p2()
                      narrowmatch = self._repo.narrowmatch()
                      for dst in self.files():
                          if not narrowmatch(dst) or dst not in self:
                              continue
                          copied = self[dst].renamed()
                          if not copied:
                              continue
                          src, srcnode = copied
                          if src in p1 and p1[src].filenode() == srcnode:
                              p1copies[dst] = src
                          elif src in p2 and p2[src].filenode() == srcnode:
                              p2copies[dst] = src
                      return p1copies, p2copies
                  def p1copies(self):
                      return self._copies[0]
                  def p2copies(self):
                      return self._copies[1]
                  def description(self):
                      return self._changeset.description
                  def branch(self):
                      return encoding.tolocal(self._changeset.extra.get("branch"))
                  def closesbranch(self):
                      return 'close' in self._changeset.extra
                  def extra(self):
                      """Return a dict of extra information."""
                      return self._changeset.extra
                  def tags(self):
                      """Return a list of byte tag names"""
                      return self._repo.nodetags(self._node)
                  def bookmarks(self):
                      """Return a list of byte bookmark names."""
                      return self._repo.nodebookmarks(self._node)
                  def phase(self):
                      return self._repo._phasecache.phase(self._repo, self._rev)
                  def hidden(self):
                      return self._rev in repoview.filterrevs(self._repo, 'visible')
                  def isinmemory(self):
                      return False
                  def children(self):
                      """return list of changectx contexts for each child changeset.
                      This returns only the immediate child changesets. Use descendants() to
                      recursively walk children.
                      """
                      c = self._repo.changelog.children(self._node)
                      return [self._repo[x] for x in c]
                  def ancestors(self):
                      for a in self._repo.changelog.ancestors([self._rev]):
                          yield self._repo[a]
                  def descendants(self):
                      """Recursively yield all children of the changeset.
                      For just the immediate children, use children()
                      """
                      for d in self._repo.changelog.descendants([self._rev]):
                          yield self._repo[d]
                  def filectx(self, path, fileid=None, filelog=None):
                      """get a file context from this changeset"""
                      if fileid is None:
                          fileid = self.filenode(path)
                      return filectx(self._repo, path, fileid=fileid,
                                     changectx=self, filelog=filelog)
                  def ancestor(self, c2, warn=False):
                      """return the "best" ancestor context of self and c2
                      If there are multiple candidates, it will show a message and check
                      merge.preferancestor configuration before falling back to the
                      revlog ancestor."""
                      # deal with workingctxs
                      n2 = c2._node
                      if n2 is None:
                          n2 = c2._parents[0]._node
                      cahs = self._repo.changelog.commonancestorsheads(self._node, n2)
                      if not cahs:
                          anc = nullid
                      elif len(cahs) == 1:
                          anc = cahs[0]
                      else:
                          # experimental config: merge.preferancestor
                          for r in self._repo.ui.configlist('merge', 'preferancestor'):
                              try:
                                  ctx = scmutil.revsymbol(self._repo, r)
                              except error.RepoLookupError:
                                  continue
                              anc = ctx.node()
                              if anc in cahs:
                                  break
                          else:
                              anc = self._repo.changelog.ancestor(self._node, n2)
                          if warn:
                              self._repo.ui.status(
                                  (_("note: using %s as ancestor of %s and %s\n") %
                                   (short(anc), short(self._node), short(n2))) +
                                  ''.join(_("      alternatively, use --config "
                                            "merge.preferancestor=%s\n") %
                                          short(n) for n in sorted(cahs) if n != anc))
                      return self._repo[anc]
                  def isancestorof(self, other):
                      """True if this changeset is an ancestor of other"""
                      return self._repo.changelog.isancestorrev(self._rev, other._rev)
                  def walk(self, match):
                      '''Generates matching file names.'''
                      # Wrap match.bad method to have message with nodeid
                      def bad(fn, msg):
                          # The manifest doesn't know about subrepos, so don't complain about
                          # paths into valid subrepos.
                          if any(fn == s or fn.startswith(s + '/')
                                 for s in self.substate):
                              return
                          match.bad(fn, _('no such file in rev %s') % self)
                      m = matchmod.badmatch(self._repo.narrowmatch(match), bad)
                      return self._manifest.walk(m)
                  def matches(self, match):
                      return self.walk(match)
              class basefilectx(object):
                  """A filecontext object represents the common logic for its children:
                  filectx: read-only access to a filerevision that is already present
                           in the repo,
                  workingfilectx: a filecontext that represents files from the working
                                  directory,
                  memfilectx: a filecontext that represents files in-memory,
                  """
                  @propertycache
                  def _filelog(self):
                      return self._repo.file(self._path)
                  @propertycache
                  def _changeid(self):
                      if r'_changectx' in self.__dict__:
                          return self._changectx.rev()
                      elif r'_descendantrev' in self.__dict__:
                          # this file context was created from a revision with a known
                          # descendant, we can (lazily) correct for linkrev aliases
                          return self._adjustlinkrev(self._descendantrev)
                      else:
                          return self._filelog.linkrev(self._filerev)
                  @propertycache
                  def _filenode(self):
                      if r'_fileid' in self.__dict__:
                          return self._filelog.lookup(self._fileid)
                      else:
                          return self._changectx.filenode(self._path)
                  @propertycache
                  def _filerev(self):
                      return self._filelog.rev(self._filenode)
                  @propertycache
                  def _repopath(self):
                      return self._path
                  def __nonzero__(self):
                      try:
                          self._filenode
                          return True
                      except error.LookupError:
                          # file is missing
                          return False
                  __bool__ = __nonzero__
                  def __bytes__(self):
                      try:
                          return "%s@%s" % (self.path(), self._changectx)
                      except error.LookupError:
                          return "%s@???" % self.path()
                  __str__ = encoding.strmethod(__bytes__)
                  def __repr__(self):
                      return r"<%s %s>" % (type(self).__name__, str(self))
                  def __hash__(self):
                      try:
                          return hash((self._path, self._filenode))
                      except AttributeError:
                          return id(self)
                  def __eq__(self, other):
                      try:
                          return (type(self) == type(other) and self._path == other._path
                                  and self._filenode == other._filenode)
                      except AttributeError:
                          return False
                  def __ne__(self, other):
                      return not (self == other)
                  def filerev(self):
                      return self._filerev
                  def filenode(self):
                      return self._filenode
                  @propertycache
                  def _flags(self):
                      return self._changectx.flags(self._path)
                  def flags(self):
                      return self._flags
                  def filelog(self):
                      return self._filelog
                  def rev(self):
                      return self._changeid
                  def linkrev(self):
                      return self._filelog.linkrev(self._filerev)
                  def node(self):
                      return self._changectx.node()
                  def hex(self):
                      return self._changectx.hex()
                  def user(self):
                      return self._changectx.user()
                  def date(self):
                      return self._changectx.date()
                  def files(self):
                      return self._changectx.files()
                  def description(self):
                      return self._changectx.description()
                  def branch(self):
                      return self._changectx.branch()
                  def extra(self):
                      return self._changectx.extra()
                  def phase(self):
                      return self._changectx.phase()
                  def phasestr(self):
                      return self._changectx.phasestr()
                  def obsolete(self):
                      return self._changectx.obsolete()
                  def instabilities(self):
                      return self._changectx.instabilities()
                  def manifest(self):
                      return self._changectx.manifest()
                  def changectx(self):
                      return self._changectx
                  def renamed(self):
                      return self._copied
                  def copysource(self):
                      return self._copied and self._copied[0]
                  def repo(self):
                      return self._repo
                  def size(self):
                      return len(self.data())
                  def path(self):
                      return self._path
                  def isbinary(self):
                      try:
                          return stringutil.binary(self.data())
                      except IOError:
                          return False
                  def isexec(self):
                      return 'x' in self.flags()
                  def islink(self):
                      return 'l' in self.flags()
                  def isabsent(self):
                      """whether this filectx represents a file not in self._changectx
                      This is mainly for merge code to detect change/delete conflicts. This is
                      expected to be True for all subclasses of basectx."""
                      return False
                  _customcmp = False
                  def cmp(self, fctx):
                      """compare with other file context
                      returns True if different than fctx.
                      """
                      if fctx._customcmp:
                          return fctx.cmp(self)
                      if self._filenode is None:
                          raise error.ProgrammingError(
                              'filectx.cmp() must be reimplemented if not backed by revlog')
                      if fctx._filenode is None:
                          if self._repo._encodefilterpats:
                              # can't rely on size() because wdir content may be decoded
                              return self._filelog.cmp(self._filenode, fctx.data())
                          if self.size() - 4 == fctx.size():
                              # size() can match:
                              # if file data starts with '\1\n', empty metadata block is
                              # prepended, which adds 4 bytes to filelog.size().
                              return self._filelog.cmp(self._filenode, fctx.data())
                      if self.size() == fctx.size():
                          # size() matches: need to compare content
                          return self._filelog.cmp(self._filenode, fctx.data())
                      # size() differs
                      return True
                  def _adjustlinkrev(self, srcrev, inclusive=False, stoprev=None):
                      """return the first ancestor of <srcrev> introducing <fnode>
                      If the linkrev of the file revision does not point to an ancestor of
                      srcrev, we'll walk down the ancestors until we find one introducing
                      this file revision.
                      :srcrev: the changeset revision we search ancestors from
                      :inclusive: if true, the src revision will also be checked
                      :stoprev: an optional revision to stop the walk at. If no introduction
                                of this file content could be found before this floor
                                revision, the function will returns "None" and stops its
                                iteration.
                      """
                      repo = self._repo
                      cl = repo.unfiltered().changelog
                      mfl = repo.manifestlog
                      # fetch the linkrev
                      lkr = self.linkrev()
                      if srcrev == lkr:
                          return lkr
                      # hack to reuse ancestor computation when searching for renames
                      memberanc = getattr(self, '_ancestrycontext', None)
                      iteranc = None
                      if srcrev is None:
                          # wctx case, used by workingfilectx during mergecopy
                          revs = [p.rev() for p in self._repo[None].parents()]
                          inclusive = True # we skipped the real (revless) source
                      else:
                          revs = [srcrev]
                      if memberanc is None:
                          memberanc = iteranc = cl.ancestors(revs, lkr,
                                                             inclusive=inclusive)
                      # check if this linkrev is an ancestor of srcrev
                      if lkr not in memberanc:
                          if iteranc is None:
                              iteranc = cl.ancestors(revs, lkr, inclusive=inclusive)
                          fnode = self._filenode
                          path = self._path
                          for a in iteranc:
                              if stoprev is not None and a < stoprev:
                                  return None
                              ac = cl.read(a) # get changeset data (we avoid object creation)
                              if path in ac[3]: # checking the 'files' field.
                                  # The file has been touched, check if the content is
                                  # similar to the one we search for.
                                  if fnode == mfl[ac[0]].readfast().get(path):
                                      return a
                          # In theory, we should never get out of that loop without a result.
                          # But if manifest uses a buggy file revision (not children of the
                          # one it replaces) we could. Such a buggy situation will likely
                          # result is crash somewhere else at to some point.
                      return lkr
                  def isintroducedafter(self, changelogrev):
                      """True if a filectx has been introduced after a given floor revision
                      """
                      if self.linkrev() >= changelogrev:
                          return True
                      introrev = self._introrev(stoprev=changelogrev)
                      if introrev is None:
                          return False
                      return introrev >= changelogrev
                  def introrev(self):
                      """return the rev of the changeset which introduced this file revision
                      This method is different from linkrev because it take into account the
                      changeset the filectx was created from. It ensures the returned
                      revision is one of its ancestors. This prevents bugs from
                      'linkrev-shadowing' when a file revision is used by multiple
                      changesets.
                      """
                      return self._introrev()
                  def _introrev(self, stoprev=None):
                      """
                      Same as `introrev` but, with an extra argument to limit changelog
                      iteration range in some internal usecase.
                      If `stoprev` is set, the `introrev` will not be searched past that
                      `stoprev` revision and "None" might be returned. This is useful to
                      limit the iteration range.
                      """
                      toprev = None
                      attrs = vars(self)
                      if r'_changeid' in attrs:
                          # We have a cached value already
                          toprev = self._changeid
                      elif r'_changectx' in attrs:
                          # We know which changelog entry we are coming from
                          toprev = self._changectx.rev()
                      if toprev is not None:
                          return self._adjustlinkrev(toprev, inclusive=True, stoprev=stoprev)
                      elif r'_descendantrev' in attrs:
                          introrev = self._adjustlinkrev(self._descendantrev, stoprev=stoprev)
                          # be nice and cache the result of the computation
                          if introrev is not None:
                              self._changeid = introrev
                          return introrev
                      else:
                          return self.linkrev()
                  def introfilectx(self):
                      """Return filectx having identical contents, but pointing to the
                      changeset revision where this filectx was introduced"""
                      introrev = self.introrev()
                      if self.rev() == introrev:
                          return self
                      return self.filectx(self.filenode(), changeid=introrev)
                  def _parentfilectx(self, path, fileid, filelog):
                      """create parent filectx keeping ancestry info for _adjustlinkrev()"""
                      fctx = filectx(self._repo, path, fileid=fileid, filelog=filelog)
                      if r'_changeid' in vars(self) or r'_changectx' in vars(self):
                          # If self is associated with a changeset (probably explicitly
                          # fed), ensure the created filectx is associated with a
                          # changeset that is an ancestor of self.changectx.
                          # This lets us later use _adjustlinkrev to get a correct link.
                          fctx._descendantrev = self.rev()
                          fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
                      elif r'_descendantrev' in vars(self):
                          # Otherwise propagate _descendantrev if we have one associated.
                          fctx._descendantrev = self._descendantrev
                          fctx._ancestrycontext = getattr(self, '_ancestrycontext', None)
                      return fctx
                  def parents(self):
                      _path = self._path
                      fl = self._filelog
                      parents = self._filelog.parents(self._filenode)
                      pl = [(_path, node, fl) for node in parents if node != nullid]
                      r = fl.renamed(self._filenode)
                      if r:
                          # - In the simple rename case, both parent are nullid, pl is empty.
                          # - In case of merge, only one of the parent is null id and should
                          # be replaced with the rename information. This parent is -always-
                          # the first one.
                          #
                          # As null id have always been filtered out in the previous list
                          # comprehension, inserting to 0 will always result in "replacing
                          # first nullid parent with rename information.
                          pl.insert(0, (r[0], r[1], self._repo.file(r[0])))
                      return [self._parentfilectx(path, fnode, l) for path, fnode, l in pl]
                  def p1(self):
                      return self.parents()[0]
                  def p2(self):
                      p = self.parents()
                      if len(p) == 2:
                          return p[1]
                      return filectx(self._repo, self._path, fileid=-1, filelog=self._filelog)
                  def annotate(self, follow=False, skiprevs=None, diffopts=None):
                      """Returns a list of annotateline objects for each line in the file
                      - line.fctx is the filectx of the node where that line was last changed
                      - line.lineno is the line number at the first appearance in the managed
                        file
                      - line.text is the data on that line (including newline character)
                      """
                      getlog = util.lrucachefunc(lambda x: self._repo.file(x))
                      def parents(f):
                          # Cut _descendantrev here to mitigate the penalty of lazy linkrev
                          # adjustment. Otherwise, p._adjustlinkrev() would walk changelog
                          # from the topmost introrev (= srcrev) down to p.linkrev() if it
                          # isn't an ancestor of the srcrev.
                          f._changeid
                          pl = f.parents()
                          # Don't return renamed parents if we aren't following.
                          if not follow:
                              pl = [p for p in pl if p.path() == f.path()]
                          # renamed filectx won't have a filelog yet, so set it
                          # from the cache to save time
                          for p in pl:
                              if not r'_filelog' in p.__dict__:
                                  p._filelog = getlog(p.path())
                          return pl
                      # use linkrev to find the first changeset where self appeared
                      base = self.introfilectx()
                      if getattr(base, '_ancestrycontext', None) is None:
                          cl = self._repo.changelog
                          if base.rev() is None:
                              # wctx is not inclusive, but works because _ancestrycontext
                              # is used to test filelog revisions
                              ac = cl.ancestors([p.rev() for p in base.parents()],
                                                inclusive=True)
                          else:
                              ac = cl.ancestors([base.rev()], inclusive=True)
                          base._ancestrycontext = ac
                      return dagop.annotate(base, parents, skiprevs=skiprevs,
                                            diffopts=diffopts)
                  def ancestors(self, followfirst=False):
                      visit = {}
                      c = self
                      if followfirst:
                          cut = 1
                      else:
                          cut = None
                      while True:
                          for parent in c.parents()[:cut]:
                              visit[(parent.linkrev(), parent.filenode())] = parent
                          if not visit:
                              break
                          c = visit.pop(max(visit))
                          yield c
                  def decodeddata(self):
                      """Returns `data()` after running repository decoding filters.
                      This is often equivalent to how the data would be expressed on disk.
                      """
                      return self._repo.wwritedata(self.path(), self.data())
              class filectx(basefilectx):
                  """A filecontext object makes access to data related to a particular
                     filerevision convenient."""
                  def __init__(self, repo, path, changeid=None, fileid=None,
                               filelog=None, changectx=None):
                      """changeid must be a revision number, if specified.
                         fileid can be a file revision or node."""
                      self._repo = repo
                      self._path = path
                      assert (changeid is not None
                              or fileid is not None
                              or changectx is not None), (
                                  "bad args: changeid=%r, fileid=%r, changectx=%r"
                                  % (changeid, fileid, changectx))
                      if filelog is not None:
                          self._filelog = filelog
                      if changeid is not None:
                          self._changeid = changeid
                      if changectx is not None:
                          self._changectx = changectx
                      if fileid is not None:
                          self._fileid = fileid
                  @propertycache
                  def _changectx(self):
                      try:
                          return self._repo[self._changeid]
                      except error.FilteredRepoLookupError:
                          # Linkrev may point to any revision in the repository.  When the
                          # repository is filtered this may lead to `filectx` trying to build
                          # `changectx` for filtered revision. In such case we fallback to
                          # creating `changectx` on the unfiltered version of the reposition.
                          # This fallback should not be an issue because `changectx` from
                          # `filectx` are not used in complex operations that care about
                          # filtering.
                          #
                          # This fallback is a cheap and dirty fix that prevent several
                          # crashes. It does not ensure the behavior is correct. However the
                          # behavior was not correct before filtering either and "incorrect
                          # behavior" is seen as better as "crash"
                          #
                          # Linkrevs have several serious troubles with filtering that are
                          # complicated to solve. Proper handling of the issue here should be
                          # considered when solving linkrev issue are on the table.
                          return self._repo.unfiltered()[self._changeid]
                  def filectx(self, fileid, changeid=None):
                      '''opens an arbitrary revision of the file without
                      opening a new filelog'''
                      return filectx(self._repo, self._path, fileid=fileid,
                                     filelog=self._filelog, changeid=changeid)
                  def rawdata(self):
                      return self._filelog.revision(self._filenode, raw=True)
                  def rawflags(self):
                      """low-level revlog flags"""
                      return self._filelog.flags(self._filerev)
                  def data(self):
                      try:
                          return self._filelog.read(self._filenode)
                      except error.CensoredNodeError:
                          if self._repo.ui.config("censor", "policy") == "ignore":
                              return ""
                          raise error.Abort(_("censored node: %s") % short(self._filenode),
                                           hint=_("set censor.policy to ignore errors"))
                  def size(self):
                      return self._filelog.size(self._filerev)
                  @propertycache
                  def _copied(self):
                      """check if file was actually renamed in this changeset revision
                      If rename logged in file revision, we report copy for changeset only
                      if file revisions linkrev points back to the changeset in question
                      or both changeset parents contain different file revisions.
                      """
                      renamed = self._filelog.renamed(self._filenode)
                      if not renamed:
                          return None
                      if self.rev() == self.linkrev():
                          return renamed
                      name = self.path()
                      fnode = self._filenode
                      for p in self._changectx.parents():
                          try:
                              if fnode == p.filenode(name):
                                  return None
                          except error.LookupError:
                              pass
                      return renamed
                  def children(self):
                      # hard for renames
                      c = self._filelog.children(self._filenode)
                      return [filectx(self._repo, self._path, fileid=x,
                                      filelog=self._filelog) for x in c]
              class committablectx(basectx):
                  """A committablectx object provides common functionality for a context that
                  wants the ability to commit, e.g. workingctx or memctx."""
                  def __init__(self, repo, text="", user=None, date=None, extra=None,
                               changes=None):
                      super(committablectx, self).__init__(repo)
                      self._rev = None
                      self._node = None
                      self._text = text
                      if date:
                          self._date = dateutil.parsedate(date)
                      if user:
                          self._user = user
                      if changes:
                          self._status = changes
                      self._extra = {}
                      if extra:
                          self._extra = extra.copy()
                      if 'branch' not in self._extra:
                          try:
                              branch = encoding.fromlocal(self._repo.dirstate.branch())
                          except UnicodeDecodeError:
                              raise error.Abort(_('branch name not in UTF-8!'))
                          self._extra['branch'] = branch
                      if self._extra['branch'] == '':
                          self._extra['branch'] = 'default'
                  def __bytes__(self):
                      return bytes(self._parents[0]) + "+"
                  __str__ = encoding.strmethod(__bytes__)
                  def __nonzero__(self):
                      return True
                  __bool__ = __nonzero__
                  def _buildflagfunc(self):
                      # Create a fallback function for getting file flags when the
                      # filesystem doesn't support them
                      copiesget = self._repo.dirstate.copies().get
                      parents = self.parents()
                      if len(parents) < 2:
                          # when we have one parent, it's easy: copy from parent
                          man = parents[0].manifest()
                          def func(f):
                              f = copiesget(f, f)
                              return man.flags(f)
                      else:
                          # merges are tricky: we try to reconstruct the unstored
                          # result from the merge (issue1802)
                          p1, p2 = parents
                          pa = p1.ancestor(p2)
                          m1, m2, ma = p1.manifest(), p2.manifest(), pa.manifest()
                          def func(f):
                              f = copiesget(f, f) # may be wrong for merges with copies
                              fl1, fl2, fla = m1.flags(f), m2.flags(f), ma.flags(f)
                              if fl1 == fl2:
                                  return fl1
                              if fl1 == fla:
                                  return fl2
                              if fl2 == fla:
                                  return fl1
                              return '' # punt for conflicts
                      return func
                  @propertycache
                  def _flagfunc(self):
                      return self._repo.dirstate.flagfunc(self._buildflagfunc)
                  @propertycache
                  def _status(self):
                      return self._repo.status()
                  @propertycache
                  def _user(self):
                      return self._repo.ui.username()
                  @propertycache
                  def _date(self):
                      ui = self._repo.ui
                      date = ui.configdate('devel', 'default-date')
                      if date is None:
                          date = dateutil.makedate()
                      return date
                  def subrev(self, subpath):
                      return None
                  def manifestnode(self):
                      return None
                  def user(self):
                      return self._user or self._repo.ui.username()
                  def date(self):
                      return self._date
                  def description(self):
                      return self._text
                  def files(self):
                      return sorted(self._status.modified + self._status.added +
                                    self._status.removed)
                  def modified(self):
                      return self._status.modified
                  def added(self):
                      return self._status.added
                  def removed(self):
                      return self._status.removed
                  def deleted(self):
                      return self._status.deleted
                  @propertycache
                  def _copies(self):
                      p1copies = {}
                      p2copies = {}
                      parents = self._repo.dirstate.parents()
                      p1manifest = self._repo[parents[0]].manifest()
                      p2manifest = self._repo[parents[1]].manifest()
                      narrowmatch = self._repo.narrowmatch()
                      for dst, src in self._repo.dirstate.copies().items():
                          if not narrowmatch(dst):
                              continue
                          if src in p1manifest:
                              p1copies[dst] = src
                          elif src in p2manifest:
                              p2copies[dst] = src
                      return p1copies, p2copies
                  def p1copies(self):
                      return self._copies[0]
                  def p2copies(self):
                      return self._copies[1]
                  def branch(self):
                      return encoding.tolocal(self._extra['branch'])
                  def closesbranch(self):
                      return 'close' in self._extra
                  def extra(self):
                      return self._extra
                  def isinmemory(self):
                      return False
                  def tags(self):
                      return []
                  def bookmarks(self):
                      b = []
                      for p in self.parents():
                          b.extend(p.bookmarks())
                      return b
                  def phase(self):
                      phase = phases.draft # default phase to draft
                      for p in self.parents():
                          phase = max(phase, p.phase())
                      return phase
                  def hidden(self):
                      return False
                  def children(self):
                      return []
                  def flags(self, path):
                      if r'_manifest' in self.__dict__:
                          try:
                              return self._manifest.flags(path)
                          except KeyError:
                              return ''
                      try:
                          return self._flagfunc(path)
                      except OSError:
                          return ''
                  def ancestor(self, c2):
                      """return the "best" ancestor context of self and c2"""
                      return self._parents[0].ancestor(c2) # punt on two parents for now
                  def walk(self, match):
                      '''Generates matching file names.'''
                      return sorted(self._repo.dirstate.walk(self._repo.narrowmatch(match),
                                                             subrepos=sorted(self.substate),
                                                             unknown=True, ignored=False))
                  def matches(self, match):
                      match = self._repo.narrowmatch(match)
                      ds = self._repo.dirstate
                      return sorted(f for f in ds.matches(match) if ds[f] != 'r')
                  def ancestors(self):
                      for p in self._parents:
                          yield p
                      for a in self._repo.changelog.ancestors(
                          [p.rev() for p in self._parents]):
                          yield self._repo[a]
                  def markcommitted(self, node):
                      """Perform post-commit cleanup necessary after committing this ctx
                      Specifically, this updates backing stores this working context
                      wraps to reflect the fact that the changes reflected by this
                      workingctx have been committed.  For example, it marks
                      modified and added files as normal in the dirstate.
                      """
                      with self._repo.dirstate.parentchange():
                          for f in self.modified() + self.added():
                              self._repo.dirstate.normal(f)
                          for f in self.removed():
                              self._repo.dirstate.drop(f)
                          self._repo.dirstate.setparents(node)
                      # write changes out explicitly, because nesting wlock at
                      # runtime may prevent 'wlock.release()' in 'repo.commit()'
                      # from immediately doing so for subsequent changing files
                      self._repo.dirstate.write(self._repo.currenttransaction())
                  def dirty(self, missing=False, merge=True, branch=True):
                      return False
              class workingctx(committablectx):
                  """A workingctx object makes access to data related to
                  the current working directory convenient.
                  date - any valid date string or (unixtime, offset), or None.
                  user - username string, or None.
                  extra - a dictionary of extra values, or None.
                  changes - a list of file lists as returned by localrepo.status()
                             or None to use the repository status.
                  """
                  def __init__(self, repo, text="", user=None, date=None, extra=None,
                               changes=None):
                      super(workingctx, self).__init__(repo, text, user, date, extra, changes)
                  def __iter__(self):
                      d = self._repo.dirstate
                      for f in d:
                          if d[f] != 'r':
                              yield f
                  def __contains__(self, key):
                      return self._repo.dirstate[key] not in "?r"
                  def hex(self):
                      return wdirhex
                  @propertycache
                  def _parents(self):
                      p = self._repo.dirstate.parents()
                      if p[1] == nullid:
                          p = p[:-1]
                      # use unfiltered repo to delay/avoid loading obsmarkers
                      unfi = self._repo.unfiltered()
                      return [changectx(self._repo, unfi.changelog.rev(n), n) for n in p]
                  def _fileinfo(self, path):
                      # populate __dict__['_manifest'] as workingctx has no _manifestdelta
                      self._manifest
                      return super(workingctx, self)._fileinfo(path)
                  def filectx(self, path, filelog=None):
                      """get a file context from the working directory"""
                      return workingfilectx(self._repo, path, workingctx=self,
                                            filelog=filelog)
                  def dirty(self, missing=False, merge=True, branch=True):
                      "check whether a working directory is modified"
                      # check subrepos first
                      for s in sorted(self.substate):
                          if self.sub(s).dirty(missing=missing):
                              return True
                      # check current working dir
                      return ((merge and self.p2()) or
                              (branch and self.branch() != self.p1().branch()) or
                              self.modified() or self.added() or self.removed() or
                              (missing and self.deleted()))
                  def add(self, list, prefix=""):
                      with self._repo.wlock():
                          ui, ds = self._repo.ui, self._repo.dirstate
                          uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
                          rejected = []
                          lstat = self._repo.wvfs.lstat
                          for f in list:
                              # ds.pathto() returns an absolute file when this is invoked from
                              # the keyword extension.  That gets flagged as non-portable on
                              # Windows, since it contains the drive letter and colon.
                              scmutil.checkportable(ui, os.path.join(prefix, f))
                              try:
                                  st = lstat(f)
                              except OSError:
                                  ui.warn(_("%s does not exist!\n") % uipath(f))
                                  rejected.append(f)
                                  continue
                              limit = ui.configbytes('ui', 'large-file-limit')
                              if limit != 0 and st.st_size > limit:
                                  ui.warn(_("%s: up to %d MB of RAM may be required "
                                            "to manage this file\n"
                                            "(use 'hg revert %s' to cancel the "
                                            "pending addition)\n")
                                          % (f, 3 * st.st_size // 1000000, uipath(f)))
                              if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
                                  ui.warn(_("%s not added: only files and symlinks "
                                            "supported currently\n") % uipath(f))
                                  rejected.append(f)
                              elif ds[f] in 'amn':
                                  ui.warn(_("%s already tracked!\n") % uipath(f))
                              elif ds[f] == 'r':
                                  ds.normallookup(f)
                              else:
                                  ds.add(f)
                          return rejected
                  def forget(self, files, prefix=""):
                      with self._repo.wlock():
                          ds = self._repo.dirstate
                          uipath = lambda f: ds.pathto(pathutil.join(prefix, f))
                          rejected = []
                          for f in files:
                              if f not in ds:
                                  self._repo.ui.warn(_("%s not tracked!\n") % uipath(f))
                                  rejected.append(f)
                              elif ds[f] != 'a':
                                  ds.remove(f)
                              else:
                                  ds.drop(f)
                          return rejected
                  def copy(self, source, dest):
                      try:
                          st = self._repo.wvfs.lstat(dest)
                      except OSError as err:
                          if err.errno != errno.ENOENT:
                              raise
                          self._repo.ui.warn(_("%s does not exist!\n")
                                             % self._repo.dirstate.pathto(dest))
                          return
                      if not (stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode)):
                          self._repo.ui.warn(_("copy failed: %s is not a file or a "
                                               "symbolic link\n")
                                             % self._repo.dirstate.pathto(dest))
                      else:
                          with self._repo.wlock():
                              ds = self._repo.dirstate
                              if ds[dest] in '?':
                                  ds.add(dest)
                              elif ds[dest] in 'r':
                                  ds.normallookup(dest)
                              ds.copy(source, dest)
                  def match(self, pats=None, include=None, exclude=None, default='glob',
                            listsubrepos=False, badfn=None):
                      r = self._repo
                      # Only a case insensitive filesystem needs magic to translate user input
                      # to actual case in the filesystem.
                      icasefs = not util.fscasesensitive(r.root)
                      return matchmod.match(r.root, r.getcwd(), pats, include, exclude,
                                            default, auditor=r.auditor, ctx=self,
                                            listsubrepos=listsubrepos, badfn=badfn,
                                            icasefs=icasefs)
                  def _filtersuspectsymlink(self, files):
                      if not files or self._repo.dirstate._checklink:
                          return files
                      # Symlink placeholders may get non-symlink-like contents
                      # via user error or dereferencing by NFS or Samba servers,
                      # so we filter out any placeholders that don't look like a
                      # symlink
                      sane = []
                      for f in files:
                          if self.flags(f) == 'l':
                              d = self[f].data()
                              if (d == '' or len(d) >= 1024 or '\n' in d
                                  or stringutil.binary(d)):
                                  self._repo.ui.debug('ignoring suspect symlink placeholder'
                                                      ' "%s"\n' % f)
                                  continue
                          sane.append(f)
                      return sane
                  def _checklookup(self, files):
                      # check for any possibly clean files
                      if not files:
                          return [], [], []
                      modified = []
                      deleted = []
                      fixup = []
                      pctx = self._parents[0]
                      # do a full compare of any files that might have changed
                      for f in sorted(files):
                          try:
                              # This will return True for a file that got replaced by a
                              # directory in the interim, but fixing that is pretty hard.
                              if (f not in pctx or self.flags(f) != pctx.flags(f)
                                  or pctx[f].cmp(self[f])):
                                  modified.append(f)
                              else:
                                  fixup.append(f)
                          except (IOError, OSError):
                              # A file become inaccessible in between? Mark it as deleted,
                              # matching dirstate behavior (issue5584).
                              # The dirstate has more complex behavior around whether a
                              # missing file matches a directory, etc, but we don't need to
                              # bother with that: if f has made it to this point, we're sure
                              # it's in the dirstate.
                              deleted.append(f)
                      return modified, deleted, fixup
                  def _poststatusfixup(self, status, fixup):
                      """update dirstate for files that are actually clean"""
                      poststatus = self._repo.postdsstatus()
                      if fixup or poststatus:
                          try:
                              oldid = self._repo.dirstate.identity()
                              # updating the dirstate is optional
                              # so we don't wait on the lock
                              # wlock can invalidate the dirstate, so cache normal _after_
                              # taking the lock
                              with self._repo.wlock(False):
                                  if self._repo.dirstate.identity() == oldid:
                                      if fixup:
                                          normal = self._repo.dirstate.normal
                                          for f in fixup:
                                              normal(f)
                                          # write changes out explicitly, because nesting
                                          # wlock at runtime may prevent 'wlock.release()'
                                          # after this block from doing so for subsequent
                                          # changing files
                                          tr = self._repo.currenttransaction()
                                          self._repo.dirstate.write(tr)
                                      if poststatus:
                                          for ps in poststatus:
                                              ps(self, status)
                                  else:
                                      # in this case, writing changes out breaks
                                      # consistency, because .hg/dirstate was
                                      # already changed simultaneously after last
                                      # caching (see also issue5584 for detail)
                                      self._repo.ui.debug('skip updating dirstate: '
                                                          'identity mismatch\n')
                          except error.LockError:
                              pass
                          finally:
                              # Even if the wlock couldn't be grabbed, clear out the list.
                              self._repo.clearpostdsstatus()
                  def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
                      '''Gets the status from the dirstate -- internal use only.'''
                      subrepos = []
                      if '.hgsub' in self:
                          subrepos = sorted(self.substate)
                      cmp, s = self._repo.dirstate.status(match, subrepos, ignored=ignored,
                                                          clean=clean, unknown=unknown)
                      # check for any possibly clean files
                      fixup = []
                      if cmp:
                          modified2, deleted2, fixup = self._checklookup(cmp)
                          s.modified.extend(modified2)
                          s.deleted.extend(deleted2)
                          if fixup and clean:
                              s.clean.extend(fixup)
                      self._poststatusfixup(s, fixup)
                      if match.always():
                          # cache for performance
                          if s.unknown or s.ignored or s.clean:
                              # "_status" is cached with list*=False in the normal route
                              self._status = scmutil.status(s.modified, s.added, s.removed,
                                                            s.deleted, [], [], [])
                          else:
                              self._status = s
                      return s
                  @propertycache
                  def _manifest(self):
                      """generate a manifest corresponding to the values in self._status
                      This reuse the file nodeid from parent, but we use special node
                      identifiers for added and modified files. This is used by manifests
                      merge to see that files are different and by update logic to avoid
                      deleting newly added files.
                      """
                      return self._buildstatusmanifest(self._status)
                  def _buildstatusmanifest(self, status):
                      """Builds a manifest that includes the given status results."""
                      parents = self.parents()
                      man = parents[0].manifest().copy()
                      ff = self._flagfunc
                      for i, l in ((addednodeid, status.added),
                                   (modifiednodeid, status.modified)):
                          for f in l:
                              man[f] = i
                              try:
                                  man.setflag(f, ff(f))
                              except OSError:
                                  pass
                      for f in status.deleted + status.removed:
                          if f in man:
                              del man[f]
                      return man
                  def _buildstatus(self, other, s, match, listignored, listclean,
                                   listunknown):
                      """build a status with respect to another context
                      This includes logic for maintaining the fast path of status when
                      comparing the working directory against its parent, which is to skip
                      building a new manifest if self (working directory) is not comparing
                      against its parent (repo['.']).
                      """
                      s = self._dirstatestatus(match, listignored, listclean, listunknown)
                      # Filter out symlinks that, in the case of FAT32 and NTFS filesystems,
                      # might have accidentally ended up with the entire contents of the file
                      # they are supposed to be linking to.
                      s.modified[:] = self._filtersuspectsymlink(s.modified)
                      if other != self._repo['.']:
                          s = super(workingctx, self)._buildstatus(other, s, match,
                                                                   listignored, listclean,
                                                                   listunknown)
                      return s
                  def _matchstatus(self, other, match):
                      """override the match method with a filter for directory patterns
                      We use inheritance to customize the match.bad method only in cases of
                      workingctx since it belongs only to the working directory when
                      comparing against the parent changeset.
                      If we aren't comparing against the working directory's parent, then we
                      just use the default match object sent to us.
                      """
                      if other != self._repo['.']:
                          def bad(f, msg):
                              # 'f' may be a directory pattern from 'match.files()',
                              # so 'f not in ctx1' is not enough
                              if f not in other and not other.hasdir(f):
                                  self._repo.ui.warn('%s: %s\n' %
                                                     (self._repo.dirstate.pathto(f), msg))
                          match.bad = bad
                      return match
                  def markcommitted(self, node):
                      super(workingctx, self).markcommitted(node)
                      sparse.aftercommit(self._repo, node)
              class committablefilectx(basefilectx):
                  """A committablefilectx provides common functionality for a file context
                  that wants the ability to commit, e.g. workingfilectx or memfilectx."""
                  def __init__(self, repo, path, filelog=None, ctx=None):
                      self._repo = repo
                      self._path = path
                      self._changeid = None
                      self._filerev = self._filenode = None
                      if filelog is not None:
                          self._filelog = filelog
                      if ctx:
                          self._changectx = ctx
                  def __nonzero__(self):
                      return True
                  __bool__ = __nonzero__
                  def linkrev(self):
                      # linked to self._changectx no matter if file is modified or not
                      return self.rev()
                  def renamed(self):
                      path = self.copysource()
                      if not path:
                          return None
                      return path, self._changectx._parents[0]._manifest.get(path, nullid)
                  def parents(self):
                      '''return parent filectxs, following copies if necessary'''
                      def filenode(ctx, path):
                          return ctx._manifest.get(path, nullid)
                      path = self._path
                      fl = self._filelog
                      pcl = self._changectx._parents
                      renamed = self.renamed()
                      if renamed:
                          pl = [renamed + (None,)]
                      else:
                          pl = [(path, filenode(pcl[0], path), fl)]
                      for pc in pcl[1:]:
                          pl.append((path, filenode(pc, path), fl))
                      return [self._parentfilectx(p, fileid=n, filelog=l)
                              for p, n, l in pl if n != nullid]
                  def children(self):
                      return []
              class workingfilectx(committablefilectx):
                  """A workingfilectx object makes access to data related to a particular
                     file in the working directory convenient."""
                  def __init__(self, repo, path, filelog=None, workingctx=None):
                      super(workingfilectx, self).__init__(repo, path, filelog, workingctx)
                  @propertycache
                  def _changectx(self):
                      return workingctx(self._repo)
                  def data(self):
                      return self._repo.wread(self._path)
                  def copysource(self):
                      return self._repo.dirstate.copied(self._path)
                  def size(self):
                      return self._repo.wvfs.lstat(self._path).st_size
                  def date(self):
                      t, tz = self._changectx.date()
                      try:
                          return (self._repo.wvfs.lstat(self._path)[stat.ST_MTIME], tz)
                      except OSError as err:
                          if err.errno != errno.ENOENT:
                              raise
                          return (t, tz)
                  def exists(self):
                      return self._repo.wvfs.exists(self._path)
                  def lexists(self):
                      return self._repo.wvfs.lexists(self._path)
                  def audit(self):
                      return self._repo.wvfs.audit(self._path)
                  def cmp(self, fctx):
                      """compare with other file context
                      returns True if different than fctx.
                      """
                      # fctx should be a filectx (not a workingfilectx)
                      # invert comparison to reuse the same code path
                      return fctx.cmp(self)
                  def remove(self, ignoremissing=False):
                      """wraps unlink for a repo's working directory"""
                      rmdir = self._repo.ui.configbool('experimental', 'removeemptydirs')
                      self._repo.wvfs.unlinkpath(self._path, ignoremissing=ignoremissing,
                                                 rmdir=rmdir)
                  def write(self, data, flags, backgroundclose=False, **kwargs):
                      """wraps repo.wwrite"""
                      self._repo.wwrite(self._path, data, flags,
                                        backgroundclose=backgroundclose,
                                        **kwargs)
                  def markcopied(self, src):
                      """marks this file a copy of `src`"""
                      if self._repo.dirstate[self._path] in "nma":
                          self._repo.dirstate.copy(src, self._path)
                  def clearunknown(self):
                      """Removes conflicting items in the working directory so that
                      ``write()`` can be called successfully.
                      """
                      wvfs = self._repo.wvfs
                      f = self._path
                      wvfs.audit(f)
                      if self._repo.ui.configbool('experimental', 'merge.checkpathconflicts'):
                          # remove files under the directory as they should already be
                          # warned and backed up
                          if wvfs.isdir(f) and not wvfs.islink(f):
                              wvfs.rmtree(f, forcibly=True)
                          for p in reversed(list(util.finddirs(f))):
                              if wvfs.isfileorlink(p):
                                  wvfs.unlink(p)
                                  break
                      else:
                          # don't remove files if path conflicts are not processed
                          if wvfs.isdir(f) and not wvfs.islink(f):
                              wvfs.removedirs(f)
                  def setflags(self, l, x):
                      self._repo.wvfs.setflags(self._path, l, x)
              class overlayworkingctx(committablectx):
                  """Wraps another mutable context with a write-back cache that can be
                  converted into a commit context.
                  self._cache[path] maps to a dict with keys: {
                      'exists': bool?
                      'date': date?
                      'data': str?
                      'flags': str?
                      'copied': str? (path or None)
                  }
                  If `exists` is True, `flags` must be non-None and 'date' is non-None. If it
                  is `False`, the file was deleted.
                  """
                  def __init__(self, repo):
                      super(overlayworkingctx, self).__init__(repo)
                      self.clean()
                  def setbase(self, wrappedctx):
                      self._wrappedctx = wrappedctx
                      self._parents = [wrappedctx]
                      # Drop old manifest cache as it is now out of date.
                      # This is necessary when, e.g., rebasing several nodes with one
                      # ``overlayworkingctx`` (e.g. with --collapse).
                      util.clearcachedproperty(self, '_manifest')
                  def data(self, path):
                      if self.isdirty(path):
                          if self._cache[path]['exists']:
-                             if self._cache[path]['data']:
+                             if self._cache[path]['data'] is not None:
                                  return self._cache[path]['data']
                              else:
                                  # Must fallback here, too, because we only set flags.
                                  return self._wrappedctx[path].data()
                          else:
                              raise error.ProgrammingError("No such file or directory: %s" %
                                                           path)
                      else:
                          return self._wrappedctx[path].data()
                  @propertycache
                  def _manifest(self):
                      parents = self.parents()
                      man = parents[0].manifest().copy()
                      flag = self._flagfunc
                      for path in self.added():
                          man[path] = addednodeid
                          man.setflag(path, flag(path))
                      for path in self.modified():
                          man[path] = modifiednodeid
                          man.setflag(path, flag(path))
                      for path in self.removed():
                          del man[path]
                      return man
                  @propertycache
                  def _flagfunc(self):
                      def f(path):
                          return self._cache[path]['flags']
                      return f
                  def files(self):
                      return sorted(self.added() + self.modified() + self.removed())
                  def modified(self):
                      return [f for f in self._cache.keys() if self._cache[f]['exists'] and
                              self._existsinparent(f)]
                  def added(self):
                      return [f for f in self._cache.keys() if self._cache[f]['exists'] and
                              not self._existsinparent(f)]
                  def removed(self):
                      return [f for f in self._cache.keys() if
                              not self._cache[f]['exists'] and self._existsinparent(f)]
                  def p1copies(self):
                      copies = self._repo._wrappedctx.p1copies().copy()
                      narrowmatch = self._repo.narrowmatch()
                      for f in self._cache.keys():
                          if not narrowmatch(f):
                              continue
                          copies.pop(f, None) # delete if it exists
                          source = self._cache[f]['copied']
                          if source:
                              copies[f] = source
                      return copies
                  def p2copies(self):
                      copies = self._repo._wrappedctx.p2copies().copy()
                      narrowmatch = self._repo.narrowmatch()
                      for f in self._cache.keys():
                          if not narrowmatch(f):
                              continue
                          copies.pop(f, None) # delete if it exists
                          source = self._cache[f]['copied']
                          if source:
                              copies[f] = source
                      return copies
                  def isinmemory(self):
                      return True
                  def filedate(self, path):
                      if self.isdirty(path):
                          return self._cache[path]['date']
                      else:
                          return self._wrappedctx[path].date()
                  def markcopied(self, path, origin):
                      self._markdirty(path, exists=True, date=self.filedate(path),
                                      flags=self.flags(path), copied=origin)
                  def copydata(self, path):
                      if self.isdirty(path):
                          return self._cache[path]['copied']
                      else:
                          raise error.ProgrammingError('copydata() called on clean context')
                  def flags(self, path):
                      if self.isdirty(path):
                          if self._cache[path]['exists']:
                              return self._cache[path]['flags']
                          else:
                              raise error.ProgrammingError("No such file or directory: %s" %
                                                           self._path)
                      else:
                          return self._wrappedctx[path].flags()
                  def __contains__(self, key):
                      if key in self._cache:
                          return self._cache[key]['exists']
                      return key in self.p1()
                  def _existsinparent(self, path):
                      try:
                          # ``commitctx` raises a ``ManifestLookupError`` if a path does not
                          # exist, unlike ``workingctx``, which returns a ``workingfilectx``
                          # with an ``exists()`` function.
                          self._wrappedctx[path]
                          return True
                      except error.ManifestLookupError:
                          return False
                  def _auditconflicts(self, path):
                      """Replicates conflict checks done by wvfs.write().
                      Since we never write to the filesystem and never call `applyupdates` in
                      IMM, we'll never check that a path is actually writable -- e.g., because
                      it adds `a/foo`, but `a` is actually a file in the other commit.
                      """
                      def fail(path, component):
                          # p1() is the base and we're receiving "writes" for p2()'s
                          # files.
                          if 'l' in self.p1()[component].flags():
                              raise error.Abort("error: %s conflicts with symlink %s "
                                                "in %d." % (path, component,
                                                            self.p1().rev()))
                          else:
                              raise error.Abort("error: '%s' conflicts with file '%s' in "
                                                "%d." % (path, component,
                                                         self.p1().rev()))
                      # Test that each new directory to be created to write this path from p2
                      # is not a file in p1.
                      components = path.split('/')
                      for i in pycompat.xrange(len(components)):
                          component = "/".join(components[0:i])
                          if component in self:
                              fail(path, component)
                      # Test the other direction -- that this path from p2 isn't a directory
                      # in p1 (test that p1 doesn't have any paths matching `path/*`).
                      match = self.match([path], default=b'path')
                      matches = self.p1().manifest().matches(match)
                      mfiles = matches.keys()
                      if len(mfiles) > 0:
                          if len(mfiles) == 1 and mfiles[0] == path:
                              return
                          # omit the files which are deleted in current IMM wctx
                          mfiles = [m for m in mfiles if m in self]
                          if not mfiles:
                              return
                          raise error.Abort("error: file '%s' cannot be written because "
                                            " '%s/' is a directory in %s (containing %d "
                                            "entries: %s)"
                                            % (path, path, self.p1(), len(mfiles),
                                               ', '.join(mfiles)))
                  def write(self, path, data, flags='', **kwargs):
                      if data is None:
                          raise error.ProgrammingError("data must be non-None")
                      self._auditconflicts(path)
                      self._markdirty(path, exists=True, data=data, date=dateutil.makedate(),
                                      flags=flags)
                  def setflags(self, path, l, x):
                      flag = ''
                      if l:
                          flag = 'l'
                      elif x:
                          flag = 'x'
                      self._markdirty(path, exists=True, date=dateutil.makedate(),
                                      flags=flag)
                  def remove(self, path):
                      self._markdirty(path, exists=False)
                  def exists(self, path):
                      """exists behaves like `lexists`, but needs to follow symlinks and
                      return False if they are broken.
                      """
                      if self.isdirty(path):
                          # If this path exists and is a symlink, "follow" it by calling
                          # exists on the destination path.
                          if (self._cache[path]['exists'] and
                                      'l' in self._cache[path]['flags']):
                              return self.exists(self._cache[path]['data'].strip())
                          else:
                              return self._cache[path]['exists']
                      return self._existsinparent(path)
                  def lexists(self, path):
                      """lexists returns True if the path exists"""
                      if self.isdirty(path):
                          return self._cache[path]['exists']
                      return self._existsinparent(path)
                  def size(self, path):
                      if self.isdirty(path):
                          if self._cache[path]['exists']:
                              return len(self._cache[path]['data'])
                          else:
                              raise error.ProgrammingError("No such file or directory: %s" %
                                                           self._path)
                      return self._wrappedctx[path].size()
                  def tomemctx(self, text, branch=None, extra=None, date=None, parents=None,
                               user=None, editor=None):
                      """Converts this ``overlayworkingctx`` into a ``memctx`` ready to be
                      committed.
                      ``text`` is the commit message.
                      ``parents`` (optional) are rev numbers.
                      """
                      # Default parents to the wrapped contexts' if not passed.
                      if parents is None:
                          parents = self._wrappedctx.parents()
                          if len(parents) == 1:
                              parents = (parents[0], None)
                      # ``parents`` is passed as rev numbers; convert to ``commitctxs``.
                      if parents[1] is None:
                          parents = (self._repo[parents[0]], None)
                      else:
                          parents = (self._repo[parents[0]], self._repo[parents[1]])
                      files = self._cache.keys()
                      def getfile(repo, memctx, path):
                          if self._cache[path]['exists']:
                              return memfilectx(repo, memctx, path,
                                                self._cache[path]['data'],
                                                'l' in self._cache[path]['flags'],
                                                'x' in self._cache[path]['flags'],
                                                self._cache[path]['copied'])
                          else:
                              # Returning None, but including the path in `files`, is
                              # necessary for memctx to register a deletion.
                              return None
                      return memctx(self._repo, parents, text, files, getfile, date=date,
                                    extra=extra, user=user, branch=branch, editor=editor)
                  def isdirty(self, path):
                      return path in self._cache
                  def isempty(self):
                      # We need to discard any keys that are actually clean before the empty
                      # commit check.
                      self._compact()
                      return len(self._cache) == 0
                  def clean(self):
                      self._cache = {}
                  def _compact(self):
                      """Removes keys from the cache that are actually clean, by comparing
                      them with the underlying context.
                      This can occur during the merge process, e.g. by passing --tool :local
                      to resolve a conflict.
                      """
                      keys = []
                      # This won't be perfect, but can help performance significantly when
                      # using things like remotefilelog.
                      scmutil.prefetchfiles(
                          self.repo(), [self.p1().rev()],
                          scmutil.matchfiles(self.repo(), self._cache.keys()))
                      for path in self._cache.keys():
                          cache = self._cache[path]
                          try:
                              underlying = self._wrappedctx[path]
                              if (underlying.data() == cache['data'] and
                                          underlying.flags() == cache['flags']):
                                  keys.append(path)
                          except error.ManifestLookupError:
                              # Path not in the underlying manifest (created).
                              continue
                      for path in keys:
                          del self._cache[path]
                      return keys
                  def _markdirty(self, path, exists, data=None, date=None, flags='',
                      copied=None):
                      # data not provided, let's see if we already have some; if not, let's
                      # grab it from our underlying context, so that we always have data if
                      # the file is marked as existing.
                      if exists and data is None:
                          oldentry = self._cache.get(path) or {}
                          data = oldentry.get('data') or self._wrappedctx[path].data()
                      self._cache[path] = {
                          'exists': exists,
                          'data': data,
                          'date': date,
                          'flags': flags,
                          'copied': copied,
                      }
                  def filectx(self, path, filelog=None):
                      return overlayworkingfilectx(self._repo, path, parent=self,
                                                   filelog=filelog)
              class overlayworkingfilectx(committablefilectx):
                  """Wrap a ``workingfilectx`` but intercepts all writes into an in-memory
                  cache, which can be flushed through later by calling ``flush()``."""
                  def __init__(self, repo, path, filelog=None, parent=None):
                      super(overlayworkingfilectx, self).__init__(repo, path, filelog,
                                                                  parent)
                      self._repo = repo
                      self._parent = parent
                      self._path = path
                  def cmp(self, fctx):
                      return self.data() != fctx.data()
                  def changectx(self):
                      return self._parent
                  def data(self):
                      return self._parent.data(self._path)
                  def date(self):
                      return self._parent.filedate(self._path)
                  def exists(self):
                      return self.lexists()
                  def lexists(self):
                      return self._parent.exists(self._path)
                  def copysource(self):
                      return self._parent.copydata(self._path)
                  def size(self):
                      return self._parent.size(self._path)
                  def markcopied(self, origin):
                      self._parent.markcopied(self._path, origin)
                  def audit(self):
                      pass
                  def flags(self):
                      return self._parent.flags(self._path)
                  def setflags(self, islink, isexec):
                      return self._parent.setflags(self._path, islink, isexec)
                  def write(self, data, flags, backgroundclose=False, **kwargs):
                      return self._parent.write(self._path, data, flags, **kwargs)
                  def remove(self, ignoremissing=False):
                      return self._parent.remove(self._path)
                  def clearunknown(self):
                      pass
              class workingcommitctx(workingctx):
                  """A workingcommitctx object makes access to data related to
                  the revision being committed convenient.
                  This hides changes in the working directory, if they aren't
                  committed in this context.
                  """
                  def __init__(self, repo, changes,
                               text="", user=None, date=None, extra=None):
                      super(workingcommitctx, self).__init__(repo, text, user, date, extra,
                                                             changes)
                  def _dirstatestatus(self, match, ignored=False, clean=False, unknown=False):
                      """Return matched files only in ``self._status``
                      Uncommitted files appear "clean" via this context, even if
                      they aren't actually so in the working directory.
                      """
                      if clean:
                          clean = [f for f in self._manifest if f not in self._changedset]
                      else:
                          clean = []
                      return scmutil.status([f for f in self._status.modified if match(f)],
                                            [f for f in self._status.added if match(f)],
                                            [f for f in self._status.removed if match(f)],
                                            [], [], [], clean)
                  @propertycache
                  def _changedset(self):
                      """Return the set of files changed in this context
                      """
                      changed = set(self._status.modified)
                      changed.update(self._status.added)
                      changed.update(self._status.removed)
                      return changed
              def makecachingfilectxfn(func):
                  """Create a filectxfn that caches based on the path.
                  We can't use util.cachefunc because it uses all arguments as the cache
                  key and this creates a cycle since the arguments include the repo and
                  memctx.
                  """
                  cache = {}
                  def getfilectx(repo, memctx, path):
                      if path not in cache:
                          cache[path] = func(repo, memctx, path)
                      return cache[path]
                  return getfilectx
              def memfilefromctx(ctx):
                  """Given a context return a memfilectx for ctx[path]
                  This is a convenience method for building a memctx based on another
                  context.
                  """
                  def getfilectx(repo, memctx, path):
                      fctx = ctx[path]
                      copysource = fctx.copysource()
                      return memfilectx(repo, memctx, path, fctx.data(),
                                        islink=fctx.islink(), isexec=fctx.isexec(),
                                        copysource=copysource)
                  return getfilectx
              def memfilefrompatch(patchstore):
                  """Given a patch (e.g. patchstore object) return a memfilectx
                  This is a convenience method for building a memctx based on a patchstore.
                  """
                  def getfilectx(repo, memctx, path):
                      data, mode, copysource = patchstore.getfile(path)
                      if data is None:
                          return None
                      islink, isexec = mode
                      return memfilectx(repo, memctx, path, data, islink=islink,
                                        isexec=isexec, copysource=copysource)
                  return getfilectx
              class memctx(committablectx):
                  """Use memctx to perform in-memory commits via localrepo.commitctx().
                  Revision information is supplied at initialization time while
                  related files data and is made available through a callback
                  mechanism.  'repo' is the current localrepo, 'parents' is a
                  sequence of two parent revisions identifiers (pass None for every
                  missing parent), 'text' is the commit message and 'files' lists
                  names of files touched by the revision (normalized and relative to
                  repository root).
                  filectxfn(repo, memctx, path) is a callable receiving the
                  repository, the current memctx object and the normalized path of
                  requested file, relative to repository root. It is fired by the
                  commit function for every file in 'files', but calls order is
                  undefined. If the file is available in the revision being
                  committed (updated or added), filectxfn returns a memfilectx
                  object. If the file was removed, filectxfn return None for recent
                  Mercurial. Moved files are represented by marking the source file
                  removed and the new file added with copy information (see
                  memfilectx).
                  user receives the committer name and defaults to current
                  repository username, date is the commit date in any format
                  supported by dateutil.parsedate() and defaults to current date, extra
                  is a dictionary of metadata or is left empty.
                  """
                  # Mercurial <= 3.1 expects the filectxfn to raise IOError for missing files.
                  # Extensions that need to retain compatibility across Mercurial 3.1 can use
                  # this field to determine what to do in filectxfn.
                  _returnnoneformissingfiles = True
                  def __init__(self, repo, parents, text, files, filectxfn, user=None,
                               date=None, extra=None, branch=None, editor=False):
                      super(memctx, self).__init__(repo, text, user, date, extra)
                      self._rev = None
                      self._node = None
                      parents = [(p or nullid) for p in parents]
                      p1, p2 = parents
                      self._parents = [self._repo[p] for p in (p1, p2)]
                      files = sorted(set(files))
                      self._files = files
                      if branch is not None:
                          self._extra['branch'] = encoding.fromlocal(branch)
                      self.substate = {}
                      if isinstance(filectxfn, patch.filestore):
                          filectxfn = memfilefrompatch(filectxfn)
                      elif not callable(filectxfn):
                          # if store is not callable, wrap it in a function
                          filectxfn = memfilefromctx(filectxfn)
                      # memoizing increases performance for e.g. vcs convert scenarios.
                      self._filectxfn = makecachingfilectxfn(filectxfn)
                      if editor:
                          self._text = editor(self._repo, self, [])
                          self._repo.savecommitmessage(self._text)
                  def filectx(self, path, filelog=None):
                      """get a file context from the working directory
                      Returns None if file doesn't exist and should be removed."""
                      return self._filectxfn(self._repo, self, path)
                  def commit(self):
                      """commit context to the repo"""
                      return self._repo.commitctx(self)
                  @propertycache
                  def _manifest(self):
                      """generate a manifest based on the return values of filectxfn"""
                      # keep this simple for now; just worry about p1
                      pctx = self._parents[0]
                      man = pctx.manifest().copy()
                      for f in self._status.modified:
                          man[f] = modifiednodeid
                      for f in self._status.added:
                          man[f] = addednodeid
                      for f in self._status.removed:
                          if f in man:
                              del man[f]
                      return man
                  @propertycache
                  def _status(self):
                      """Calculate exact status from ``files`` specified at construction
                      """
                      man1 = self.p1().manifest()
                      p2 = self._parents[1]
                      # "1 < len(self._parents)" can't be used for checking
                      # existence of the 2nd parent, because "memctx._parents" is
                      # explicitly initialized by the list, of which length is 2.
                      if p2.node() != nullid:
                          man2 = p2.manifest()
                          managing = lambda f: f in man1 or f in man2
                      else:
                          managing = lambda f: f in man1
                      modified, added, removed = [], [], []
                      for f in self._files:
                          if not managing(f):
                              added.append(f)
                          elif self[f]:
                              modified.append(f)
                          else:
                              removed.append(f)
                      return scmutil.status(modified, added, removed, [], [], [], [])
              class memfilectx(committablefilectx):
                  """memfilectx represents an in-memory file to commit.
                  See memctx and committablefilectx for more details.
                  """
                  def __init__(self, repo, changectx, path, data, islink=False,
                               isexec=False, copysource=None):
                      """
                      path is the normalized file path relative to repository root.
                      data is the file content as a string.
                      islink is True if the file is a symbolic link.
                      isexec is True if the file is executable.
                      copied is the source file path if current file was copied in the
                      revision being committed, or None."""
                      super(memfilectx, self).__init__(repo, path, None, changectx)
                      self._data = data
                      if islink:
                          self._flags = 'l'
                      elif isexec:
                          self._flags = 'x'
                      else:
                          self._flags = ''
                      self._copysource = copysource
                  def copysource(self):
                      return self._copysource
                  def cmp(self, fctx):
                      return self.data() != fctx.data()
                  def data(self):
                      return self._data
                  def remove(self, ignoremissing=False):
                      """wraps unlink for a repo's working directory"""
                      # need to figure out what to do here
                      del self._changectx[self._path]
                  def write(self, data, flags, **kwargs):
                      """wraps repo.wwrite"""
                      self._data = data
              class metadataonlyctx(committablectx):
                  """Like memctx but it's reusing the manifest of different commit.
                  Intended to be used by lightweight operations that are creating
                  metadata-only changes.
                  Revision information is supplied at initialization time.  'repo' is the
                  current localrepo, 'ctx' is original revision which manifest we're reuisng
                  'parents' is a sequence of two parent revisions identifiers (pass None for
                  every missing parent), 'text' is the commit.
                  user receives the committer name and defaults to current repository
                  username, date is the commit date in any format supported by
                  dateutil.parsedate() and defaults to current date, extra is a dictionary of
                  metadata or is left empty.
                  """
                  def __init__(self, repo, originalctx, parents=None, text=None, user=None,
                               date=None, extra=None, editor=False):
                      if text is None:
                          text = originalctx.description()
                      super(metadataonlyctx, self).__init__(repo, text, user, date, extra)
                      self._rev = None
                      self._node = None
                      self._originalctx = originalctx
                      self._manifestnode = originalctx.manifestnode()
                      if parents is None:
                          parents = originalctx.parents()
                      else:
                          parents = [repo[p] for p in parents if p is not None]
                      parents = parents[:]
                      while len(parents) < 2:
                          parents.append(repo[nullid])
                      p1, p2 = self._parents = parents
                      # sanity check to ensure that the reused manifest parents are
                      # manifests of our commit parents
                      mp1, mp2 = self.manifestctx().parents
                      if p1 != nullid and p1.manifestnode() != mp1:
                          raise RuntimeError(r"can't reuse the manifest: its p1 "
                                             r"doesn't match the new ctx p1")
                      if p2 != nullid and p2.manifestnode() != mp2:
                          raise RuntimeError(r"can't reuse the manifest: "
                                             r"its p2 doesn't match the new ctx p2")
                      self._files = originalctx.files()
                      self.substate = {}
                      if editor:
                          self._text = editor(self._repo, self, [])
                          self._repo.savecommitmessage(self._text)
                  def manifestnode(self):
                      return self._manifestnode
                  @property
                  def _manifestctx(self):
                      return self._repo.manifestlog[self._manifestnode]
                  def filectx(self, path, filelog=None):
                      return self._originalctx.filectx(path, filelog=filelog)
                  def commit(self):
                      """commit context to the repo"""
                      return self._repo.commitctx(self)
                  @property
                  def _manifest(self):
                      return self._originalctx.manifest()
                  @propertycache
                  def _status(self):
                      """Calculate exact status from ``files`` specified in the ``origctx``
                      and parents manifests.
                      """
                      man1 = self.p1().manifest()
                      p2 = self._parents[1]
                      # "1 < len(self._parents)" can't be used for checking
                      # existence of the 2nd parent, because "metadataonlyctx._parents" is
                      # explicitly initialized by the list, of which length is 2.
                      if p2.node() != nullid:
                          man2 = p2.manifest()
                          managing = lambda f: f in man1 or f in man2
                      else:
                          managing = lambda f: f in man1
                      modified, added, removed = [], [], []
                      for f in self._files:
                          if not managing(f):
                              added.append(f)
                          elif f in self:
                              modified.append(f)
                          else:
                              removed.append(f)
                      return scmutil.status(modified, added, removed, [], [], [], [])
              class arbitraryfilectx(object):
                  """Allows you to use filectx-like functions on a file in an arbitrary
                  location on disk, possibly not in the working directory.
                  """
                  def __init__(self, path, repo=None):
                      # Repo is optional because contrib/simplemerge uses this class.
                      self._repo = repo
                      self._path = path
                  def cmp(self, fctx):
                      # filecmp follows symlinks whereas `cmp` should not, so skip the fast
                      # path if either side is a symlink.
                      symlinks = ('l' in self.flags() or 'l' in fctx.flags())
                      if not symlinks and isinstance(fctx, workingfilectx) and self._repo:
                          # Add a fast-path for merge if both sides are disk-backed.
                          # Note that filecmp uses the opposite return values (True if same)
                          # from our cmp functions (True if different).
                          return not filecmp.cmp(self.path(), self._repo.wjoin(fctx.path()))
                      return self.data() != fctx.data()
                  def path(self):
                      return self._path
                  def flags(self):
                      return ''
                  def data(self):
                      return util.readfile(self._path)
                  def decodeddata(self):
                      with open(self._path, "rb") as f:
                          return f.read()
                  def remove(self):
                      util.unlink(self._path)
                  def write(self, data, flags, **kwargs):
                      assert not flags
                      with open(self._path, "wb") as f:
                          f.write(data)

mercurial/exchange.py

0 +5 -8

              # exchange.py - utility to exchange data between repos.
              #
              # Copyright 2005-2007 Matt Mackall <mpm@selenic.com>
              #
              # This software may be used and distributed according to the terms of the
              # GNU General Public License version 2 or any later version.
              from __future__ import absolute_import
              import collections
              import hashlib
              from .i18n import _
              from .node import (
                  bin,
                  hex,
                  nullid,
                  nullrev,
              )
              from .thirdparty import (
                  attr,
              )
              from . import (
                  bookmarks as bookmod,
                  bundle2,
                  changegroup,
                  discovery,
                  error,
                  exchangev2,
                  lock as lockmod,
                  logexchange,
                  narrowspec,
                  obsolete,
                  phases,
                  pushkey,
                  pycompat,
                  repository,
                  scmutil,
                  sslutil,
                  streamclone,
                  url as urlmod,
                  util,
                  wireprototypes,
              )
              from .utils import (
                  stringutil,
              )
              urlerr = util.urlerr
              urlreq = util.urlreq
-             _NARROWACL_SECTION = 'narrowhgacl'
+             _NARROWACL_SECTION = 'narrowacl'
              # Maps bundle version human names to changegroup versions.
              _bundlespeccgversions = {'v1': '01',
                                       'v2': '02',
                                       'packed1': 's1',
                                       'bundle2': '02', #legacy
                                      }
              # Maps bundle version with content opts to choose which part to bundle
              _bundlespeccontentopts = {
                  'v1': {
                      'changegroup': True,
                      'cg.version': '01',
                      'obsolescence': False,
                      'phases': False,
                      'tagsfnodescache': False,
                      'revbranchcache': False
                  },
                  'v2': {
                      'changegroup': True,
                      'cg.version': '02',
                      'obsolescence': False,
                      'phases': False,
                      'tagsfnodescache': True,
                      'revbranchcache': True
                  },
                  'packed1' : {
                      'cg.version': 's1'
                  }
              }
              _bundlespeccontentopts['bundle2'] = _bundlespeccontentopts['v2']
              _bundlespecvariants = {"streamv2": {"changegroup": False, "streamv2": True,
                                                  "tagsfnodescache": False,
                                                  "revbranchcache": False}}
              # Compression engines allowed in version 1. THIS SHOULD NEVER CHANGE.
              _bundlespecv1compengines = {'gzip', 'bzip2', 'none'}
              @attr.s
              class bundlespec(object):
                  compression = attr.ib()
                  wirecompression = attr.ib()
                  version = attr.ib()
                  wireversion = attr.ib()
                  params = attr.ib()
                  contentopts = attr.ib()
              def parsebundlespec(repo, spec, strict=True):
                  """Parse a bundle string specification into parts.
                  Bundle specifications denote a well-defined bundle/exchange format.
                  The content of a given specification should not change over time in
                  order to ensure that bundles produced by a newer version of Mercurial are
                  readable from an older version.
                  The string currently has the form:
                     <compression>-<type>[;<parameter0>[;<parameter1>]]
                  Where <compression> is one of the supported compression formats
                  and <type> is (currently) a version string. A ";" can follow the type and
                  all text afterwards is interpreted as URI encoded, ";" delimited key=value
                  pairs.
                  If ``strict`` is True (the default) <compression> is required. Otherwise,
                  it is optional.
                  Returns a bundlespec object of (compression, version, parameters).
                  Compression will be ``None`` if not in strict mode and a compression isn't
                  defined.
                  An ``InvalidBundleSpecification`` is raised when the specification is
                  not syntactically well formed.
                  An ``UnsupportedBundleSpecification`` is raised when the compression or
                  bundle type/version is not recognized.
                  Note: this function will likely eventually return a more complex data
                  structure, including bundle2 part information.
                  """
                  def parseparams(s):
                      if ';' not in s:
                          return s, {}
                      params = {}
                      version, paramstr = s.split(';', 1)
                      for p in paramstr.split(';'):
                          if '=' not in p:
                              raise error.InvalidBundleSpecification(
                                  _('invalid bundle specification: '
                                    'missing "=" in parameter: %s') % p)
                          key, value = p.split('=', 1)
                          key = urlreq.unquote(key)
                          value = urlreq.unquote(value)
                          params[key] = value
                      return version, params
                  if strict and '-' not in spec:
                      raise error.InvalidBundleSpecification(
                              _('invalid bundle specification; '
                                'must be prefixed with compression: %s') % spec)
                  if '-' in spec:
                      compression, version = spec.split('-', 1)
                      if compression not in util.compengines.supportedbundlenames:
                          raise error.UnsupportedBundleSpecification(
                                  _('%s compression is not supported') % compression)
                      version, params = parseparams(version)
                      if version not in _bundlespeccgversions:
                          raise error.UnsupportedBundleSpecification(
                                  _('%s is not a recognized bundle version') % version)
                  else:
                      # Value could be just the compression or just the version, in which
                      # case some defaults are assumed (but only when not in strict mode).
                      assert not strict
                      spec, params = parseparams(spec)
                      if spec in util.compengines.supportedbundlenames:
                          compression = spec
                          version = 'v1'
                          # Generaldelta repos require v2.
                          if 'generaldelta' in repo.requirements:
                              version = 'v2'
                          # Modern compression engines require v2.
                          if compression not in _bundlespecv1compengines:
                              version = 'v2'
                      elif spec in _bundlespeccgversions:
                          if spec == 'packed1':
                              compression = 'none'
                          else:
                              compression = 'bzip2'
                          version = spec
                      else:
                          raise error.UnsupportedBundleSpecification(
                                  _('%s is not a recognized bundle specification') % spec)
                  # Bundle version 1 only supports a known set of compression engines.
                  if version == 'v1' and compression not in _bundlespecv1compengines:
                      raise error.UnsupportedBundleSpecification(
                          _('compression engine %s is not supported on v1 bundles') %
                          compression)
                  # The specification for packed1 can optionally declare the data formats
                  # required to apply it. If we see this metadata, compare against what the
                  # repo supports and error if the bundle isn't compatible.
                  if version == 'packed1' and 'requirements' in params:
                      requirements = set(params['requirements'].split(','))
                      missingreqs = requirements - repo.supportedformats
                      if missingreqs:
                          raise error.UnsupportedBundleSpecification(
                                  _('missing support for repository features: %s') %
                                    ', '.join(sorted(missingreqs)))
                  # Compute contentopts based on the version
                  contentopts = _bundlespeccontentopts.get(version, {}).copy()
                  # Process the variants
                  if "stream" in params and params["stream"] == "v2":
                      variant = _bundlespecvariants["streamv2"]
                      contentopts.update(variant)
                  engine = util.compengines.forbundlename(compression)
                  compression, wirecompression = engine.bundletype()
                  wireversion = _bundlespeccgversions[version]
                  return bundlespec(compression, wirecompression, version, wireversion,
                                    params, contentopts)
              def readbundle(ui, fh, fname, vfs=None):
                  header = changegroup.readexactly(fh, 4)
                  alg = None
                  if not fname:
                      fname = "stream"
                      if not header.startswith('HG') and header.startswith('\0'):
                          fh = changegroup.headerlessfixup(fh, header)
                          header = "HG10"
                          alg = 'UN'
                  elif vfs:
                      fname = vfs.join(fname)
                  magic, version = header[0:2], header[2:4]
                  if magic != 'HG':
                      raise error.Abort(_('%s: not a Mercurial bundle') % fname)
                  if version == '10':
                      if alg is None:
                          alg = changegroup.readexactly(fh, 2)
                      return changegroup.cg1unpacker(fh, alg)
                  elif version.startswith('2'):
                      return bundle2.getunbundler(ui, fh, magicstring=magic + version)
                  elif version == 'S1':
                      return streamclone.streamcloneapplier(fh)
                  else:
                      raise error.Abort(_('%s: unknown bundle version %s') % (fname, version))
              def getbundlespec(ui, fh):
                  """Infer the bundlespec from a bundle file handle.
                  The input file handle is seeked and the original seek position is not
                  restored.
                  """
                  def speccompression(alg):
                      try:
                          return util.compengines.forbundletype(alg).bundletype()[0]
                      except KeyError:
                          return None
                  b = readbundle(ui, fh, None)
                  if isinstance(b, changegroup.cg1unpacker):
                      alg = b._type
                      if alg == '_truncatedBZ':
                          alg = 'BZ'
                      comp = speccompression(alg)
                      if not comp:
                          raise error.Abort(_('unknown compression algorithm: %s') % alg)
                      return '%s-v1' % comp
                  elif isinstance(b, bundle2.unbundle20):
                      if 'Compression' in b.params:
                          comp = speccompression(b.params['Compression'])
                          if not comp:
                              raise error.Abort(_('unknown compression algorithm: %s') % comp)
                      else:
                          comp = 'none'
                      version = None
                      for part in b.iterparts():
                          if part.type == 'changegroup':
                              version = part.params['version']
                              if version in ('01', '02'):
                                  version = 'v2'
                              else:
                                  raise error.Abort(_('changegroup version %s does not have '
                                                      'a known bundlespec') % version,
                                                    hint=_('try upgrading your Mercurial '
                                                            'client'))
                          elif part.type == 'stream2' and version is None:
                              # A stream2 part requires to be part of a v2 bundle
                              requirements = urlreq.unquote(part.params['requirements'])
                              splitted = requirements.split()
                              params = bundle2._formatrequirementsparams(splitted)
                              return 'none-v2;stream=v2;%s' % params
                      if not version:
                          raise error.Abort(_('could not identify changegroup version in '
                                              'bundle'))
                      return '%s-%s' % (comp, version)
                  elif isinstance(b, streamclone.streamcloneapplier):
                      requirements = streamclone.readbundle1header(fh)[2]
                      formatted = bundle2._formatrequirementsparams(requirements)
                      return 'none-packed1;%s' % formatted
                  else:
                      raise error.Abort(_('unknown bundle type: %s') % b)
              def _computeoutgoing(repo, heads, common):
                  """Computes which revs are outgoing given a set of common
                  and a set of heads.
                  This is a separate function so extensions can have access to
                  the logic.
                  Returns a discovery.outgoing object.
                  """
                  cl = repo.changelog
                  if common:
                      hasnode = cl.hasnode
                      common = [n for n in common if hasnode(n)]
                  else:
                      common = [nullid]
                  if not heads:
                      heads = cl.heads()
                  return discovery.outgoing(repo, common, heads)
              def _checkpublish(pushop):
                  repo = pushop.repo
                  ui = repo.ui
                  behavior = ui.config('experimental', 'auto-publish')
                  if pushop.publish or behavior not in ('warn', 'confirm', 'abort'):
                      return
                  remotephases = listkeys(pushop.remote, 'phases')
                  if not remotephases.get('publishing', False):
                      return
                  if pushop.revs is None:
                      published = repo.filtered('served').revs('not public()')
                  else:
                      published = repo.revs('::%ln - public()', pushop.revs)
                  if published:
                      if behavior == 'warn':
                          ui.warn(_('%i changesets about to be published\n')
                                  % len(published))
                      elif behavior == 'confirm':
                          if ui.promptchoice(_('push and publish %i changesets (yn)?'
                                               '$$ &Yes $$ &No') % len(published)):
                              raise error.Abort(_('user quit'))
                      elif behavior == 'abort':
                          msg = _('push would publish %i changesets') % len(published)
                          hint = _("use --publish or adjust 'experimental.auto-publish'"
                                   " config")
                          raise error.Abort(msg, hint=hint)
              def _forcebundle1(op):
                  """return true if a pull/push must use bundle1
                  This function is used to allow testing of the older bundle version"""
                  ui = op.repo.ui
                  # The goal is this config is to allow developer to choose the bundle
                  # version used during exchanged. This is especially handy during test.
                  # Value is a list of bundle version to be picked from, highest version
                  # should be used.
                  #
                  # developer config: devel.legacy.exchange
                  exchange = ui.configlist('devel', 'legacy.exchange')
                  forcebundle1 = 'bundle2' not in exchange and 'bundle1' in exchange
                  return forcebundle1 or not op.remote.capable('bundle2')
              class pushoperation(object):
                  """A object that represent a single push operation
                  Its purpose is to carry push related state and very common operations.
                  A new pushoperation should be created at the beginning of each push and
                  discarded afterward.
                  """
                  def __init__(self, repo, remote, force=False, revs=None, newbranch=False,
                               bookmarks=(), publish=False, pushvars=None):
                      # repo we push from
                      self.repo = repo
                      self.ui = repo.ui
                      # repo we push to
                      self.remote = remote
                      # force option provided
                      self.force = force
                      # revs to be pushed (None is "all")
                      self.revs = revs
                      # bookmark explicitly pushed
                      self.bookmarks = bookmarks
                      # allow push of new branch
                      self.newbranch = newbranch
                      # step already performed
                      # (used to check what steps have been already performed through bundle2)
                      self.stepsdone = set()
                      # Integer version of the changegroup push result
                      # - None means nothing to push
                      # - 0 means HTTP error
                      # - 1 means we pushed and remote head count is unchanged *or*
                      #   we have outgoing changesets but refused to push
                      # - other values as described by addchangegroup()
                      self.cgresult = None
                      # Boolean value for the bookmark push
                      self.bkresult = None
                      # discover.outgoing object (contains common and outgoing data)
                      self.outgoing = None
                      # all remote topological heads before the push
                      self.remoteheads = None
                      # Details of the remote branch pre and post push
                      #
                      # mapping: {'branch': ([remoteheads],
                      #                      [newheads],
                      #                      [unsyncedheads],
                      #                      [discardedheads])}
                      # - branch: the branch name
                      # - remoteheads: the list of remote heads known locally
                      #                None if the branch is new
                      # - newheads: the new remote heads (known locally) with outgoing pushed
                      # - unsyncedheads: the list of remote heads unknown locally.
                      # - discardedheads: the list of remote heads made obsolete by the push
                      self.pushbranchmap = None
                      # testable as a boolean indicating if any nodes are missing locally.
                      self.incoming = None
                      # summary of the remote phase situation
                      self.remotephases = None
                      # phases changes that must be pushed along side the changesets
                      self.outdatedphases = None
                      # phases changes that must be pushed if changeset push fails
                      self.fallbackoutdatedphases = None
                      # outgoing obsmarkers
                      self.outobsmarkers = set()
                      # outgoing bookmarks
                      self.outbookmarks = []
                      # transaction manager
                      self.trmanager = None
                      # map { pushkey partid -> callback handling failure}
                      # used to handle exception from mandatory pushkey part failure
                      self.pkfailcb = {}
                      # an iterable of pushvars or None
                      self.pushvars = pushvars
                      # publish pushed changesets
                      self.publish = publish
                  @util.propertycache
                  def futureheads(self):
                      """future remote heads if the changeset push succeeds"""
                      return self.outgoing.missingheads
                  @util.propertycache
                  def fallbackheads(self):
                      """future remote heads if the changeset push fails"""
                      if self.revs is None:
                          # not target to push, all common are relevant
                          return self.outgoing.commonheads
                      unfi = self.repo.unfiltered()
                      # I want cheads = heads(::missingheads and ::commonheads)
                      # (missingheads is revs with secret changeset filtered out)
                      #
                      # This can be expressed as:
                      #     cheads = ( (missingheads and ::commonheads)
                      #              + (commonheads and ::missingheads))"
                      #              )
                      #
                      # while trying to push we already computed the following:
                      #     common = (::commonheads)
                      #     missing = ((commonheads::missingheads) - commonheads)
                      #
                      # We can pick:
                      # * missingheads part of common (::commonheads)
                      common = self.outgoing.common
                      nm = self.repo.changelog.nodemap
                      cheads = [node for node in self.revs if nm[node] in common]
                      # and
                      # * commonheads parents on missing
                      revset = unfi.set('%ln and parents(roots(%ln))',
                                       self.outgoing.commonheads,
                                       self.outgoing.missing)
                      cheads.extend(c.node() for c in revset)
                      return cheads
                  @property
                  def commonheads(self):
                      """set of all common heads after changeset bundle push"""
                      if self.cgresult:
                          return self.futureheads
                      else:
                          return self.fallbackheads
              # mapping of message used when pushing bookmark
              bookmsgmap = {'update': (_("updating bookmark %s\n"),
                                       _('updating bookmark %s failed!\n')),
                            'export': (_("exporting bookmark %s\n"),
                                       _('exporting bookmark %s failed!\n')),
                            'delete': (_("deleting remote bookmark %s\n"),
                                       _('deleting remote bookmark %s failed!\n')),
                            }
              def push(repo, remote, force=False, revs=None, newbranch=False, bookmarks=(),
                       publish=False, opargs=None):
                  '''Push outgoing changesets (limited by revs) from a local
                  repository to remote. Return an integer:
                    - None means nothing to push
                    - 0 means HTTP error
                    - 1 means we pushed and remote head count is unchanged *or*
                      we have outgoing changesets but refused to push
                    - other values as described by addchangegroup()
                  '''
                  if opargs is None:
                      opargs = {}
                  pushop = pushoperation(repo, remote, force, revs, newbranch, bookmarks,
                                         publish, **pycompat.strkwargs(opargs))
                  if pushop.remote.local():
                      missing = (set(pushop.repo.requirements)
                                 - pushop.remote.local().supported)
                      if missing:
                          msg = _("required features are not"
                                  " supported in the destination:"
                                  " %s") % (', '.join(sorted(missing)))
                          raise error.Abort(msg)
                  if not pushop.remote.canpush():
                      raise error.Abort(_("destination does not support push"))
                  if not pushop.remote.capable('unbundle'):
                      raise error.Abort(_('cannot push: destination does not support the '
                                          'unbundle wire protocol command'))
                  # get lock as we might write phase data
                  wlock = lock = None
                  try:
                      # bundle2 push may receive a reply bundle touching bookmarks or other
                      # things requiring the wlock. Take it now to ensure proper ordering.
                      maypushback = pushop.ui.configbool('experimental', 'bundle2.pushback')
                      if (not _forcebundle1(pushop)) and maypushback:
                          wlock = pushop.repo.wlock()
                      lock = pushop.repo.lock()
                      pushop.trmanager = transactionmanager(pushop.repo,
                                                            'push-response',
                                                            pushop.remote.url())
                  except error.LockUnavailable as err:
                      # source repo cannot be locked.
                      # We do not abort the push, but just disable the local phase
                      # synchronisation.
                      msg = ('cannot lock source repository: %s\n'
                             % stringutil.forcebytestr(err))
                      pushop.ui.debug(msg)
                  with wlock or util.nullcontextmanager():
                      with lock or util.nullcontextmanager():
                          with pushop.trmanager or util.nullcontextmanager():
                              pushop.repo.checkpush(pushop)
                              _checkpublish(pushop)
                              _pushdiscovery(pushop)
                              if not _forcebundle1(pushop):
                                  _pushbundle2(pushop)
                              _pushchangeset(pushop)
                              _pushsyncphase(pushop)
                              _pushobsolete(pushop)
                              _pushbookmark(pushop)
                  if repo.ui.configbool('experimental', 'remotenames'):
                      logexchange.pullremotenames(repo, remote)
                  return pushop
              # list of steps to perform discovery before push
              pushdiscoveryorder = []
              # Mapping between step name and function
              #
              # This exists to help extensions wrap steps if necessary
              pushdiscoverymapping = {}
              def pushdiscovery(stepname):
                  """decorator for function performing discovery before push
                  The function is added to the step -> function mapping and appended to the
                  list of steps.  Beware that decorated function will be added in order (this
                  may matter).
                  You can only use this decorator for a new step, if you want to wrap a step
                  from an extension, change the pushdiscovery dictionary directly."""
                  def dec(func):
                      assert stepname not in pushdiscoverymapping
                      pushdiscoverymapping[stepname] = func
                      pushdiscoveryorder.append(stepname)
                      return func
                  return dec
              def _pushdiscovery(pushop):
                  """Run all discovery steps"""
                  for stepname in pushdiscoveryorder:
                      step = pushdiscoverymapping[stepname]
                      step(pushop)
              @pushdiscovery('changeset')
              def _pushdiscoverychangeset(pushop):
                  """discover the changeset that need to be pushed"""
                  fci = discovery.findcommonincoming
                  if pushop.revs:
                      commoninc = fci(pushop.repo, pushop.remote, force=pushop.force,
                                      ancestorsof=pushop.revs)
                  else:
                      commoninc = fci(pushop.repo, pushop.remote, force=pushop.force)
                  common, inc, remoteheads = commoninc
                  fco = discovery.findcommonoutgoing
                  outgoing = fco(pushop.repo, pushop.remote, onlyheads=pushop.revs,
                                 commoninc=commoninc, force=pushop.force)
                  pushop.outgoing = outgoing
                  pushop.remoteheads = remoteheads
                  pushop.incoming = inc
              @pushdiscovery('phase')
              def _pushdiscoveryphase(pushop):
                  """discover the phase that needs to be pushed
                  (computed for both success and failure case for changesets push)"""
                  outgoing = pushop.outgoing
                  unfi = pushop.repo.unfiltered()
                  remotephases = listkeys(pushop.remote, 'phases')
                  if (pushop.ui.configbool('ui', '_usedassubrepo')
                      and remotephases    # server supports phases
                      and not pushop.outgoing.missing # no changesets to be pushed
                      and remotephases.get('publishing', False)):
                      # When:
                      # - this is a subrepo push
                      # - and remote support phase
                      # - and no changeset are to be pushed
                      # - and remote is publishing
                      # We may be in issue 3781 case!
                      # We drop the possible phase synchronisation done by
                      # courtesy to publish changesets possibly locally draft
                      # on the remote.
                      pushop.outdatedphases = []
                      pushop.fallbackoutdatedphases = []
                      return
                  pushop.remotephases = phases.remotephasessummary(pushop.repo,
                                                                   pushop.fallbackheads,
                                                                   remotephases)
                  droots = pushop.remotephases.draftroots
                  extracond = ''
                  if not pushop.remotephases.publishing:
                      extracond = ' and public()'
                  revset = 'heads((%%ln::%%ln) %s)' % extracond
                  # Get the list of all revs draft on remote by public here.
                  # XXX Beware that revset break if droots is not strictly
                  # XXX root we may want to ensure it is but it is costly
                  fallback = list(unfi.set(revset, droots, pushop.fallbackheads))
                  if not pushop.remotephases.publishing and pushop.publish:
                      future = list(unfi.set('%ln and (not public() or %ln::)',
                                             pushop.futureheads, droots))
                  elif not outgoing.missing:
                      future = fallback
                  else:
                      # adds changeset we are going to push as draft
                      #
                      # should not be necessary for publishing server, but because of an
                      # issue fixed in xxxxx we have to do it anyway.
                      fdroots = list(unfi.set('roots(%ln  + %ln::)',
                                     outgoing.missing, droots))
                      fdroots = [f.node() for f in fdroots]
                      future = list(unfi.set(revset, fdroots, pushop.futureheads))
                  pushop.outdatedphases = future
                  pushop.fallbackoutdatedphases = fallback
              @pushdiscovery('obsmarker')
              def _pushdiscoveryobsmarkers(pushop):
                  if not obsolete.isenabled(pushop.repo, obsolete.exchangeopt):
                      return
                  if not pushop.repo.obsstore:
                      return
                  if 'obsolete' not in listkeys(pushop.remote, 'namespaces'):
                      return
                  repo = pushop.repo
                  # very naive computation, that can be quite expensive on big repo.
                  # However: evolution is currently slow on them anyway.
                  nodes = (c.node() for c in repo.set('::%ln', pushop.futureheads))
                  pushop.outobsmarkers = pushop.repo.obsstore.relevantmarkers(nodes)
              @pushdiscovery('bookmarks')
              def _pushdiscoverybookmarks(pushop):
                  ui = pushop.ui
                  repo = pushop.repo.unfiltered()
                  remote = pushop.remote
                  ui.debug("checking for updated bookmarks\n")
                  ancestors = ()
                  if pushop.revs:
                      revnums = pycompat.maplist(repo.changelog.rev, pushop.revs)
                      ancestors = repo.changelog.ancestors(revnums, inclusive=True)
                  remotebookmark = listkeys(remote, 'bookmarks')
                  explicit = {repo._bookmarks.expandname(bookmark)
                              for bookmark in pushop.bookmarks}
                  remotebookmark = bookmod.unhexlifybookmarks(remotebookmark)
                  comp = bookmod.comparebookmarks(repo, repo._bookmarks, remotebookmark)
                  def safehex(x):
                      if x is None:
                          return x
                      return hex(x)
                  def hexifycompbookmarks(bookmarks):
                      return [(b, safehex(scid), safehex(dcid))
                              for (b, scid, dcid) in bookmarks]
                  comp = [hexifycompbookmarks(marks) for marks in comp]
                  return _processcompared(pushop, ancestors, explicit, remotebookmark, comp)
              def _processcompared(pushop, pushed, explicit, remotebms, comp):
                  """take decision on bookmark to pull from the remote bookmark
                  Exist to help extensions who want to alter this behavior.
                  """
                  addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = comp
                  repo = pushop.repo
                  for b, scid, dcid in advsrc:
                      if b in explicit:
                          explicit.remove(b)
                      if not pushed or repo[scid].rev() in pushed:
                          pushop.outbookmarks.append((b, dcid, scid))
                  # search added bookmark
                  for b, scid, dcid in addsrc:
                      if b in explicit:
                          explicit.remove(b)
                          pushop.outbookmarks.append((b, '', scid))
                  # search for overwritten bookmark
                  for b, scid, dcid in list(advdst) + list(diverge) + list(differ):
                      if b in explicit:
                          explicit.remove(b)
                          pushop.outbookmarks.append((b, dcid, scid))
                  # search for bookmark to delete
                  for b, scid, dcid in adddst:
                      if b in explicit:
                          explicit.remove(b)
                          # treat as "deleted locally"
                          pushop.outbookmarks.append((b, dcid, ''))
                  # identical bookmarks shouldn't get reported
                  for b, scid, dcid in same:
                      if b in explicit:
                          explicit.remove(b)
                  if explicit:
                      explicit = sorted(explicit)
                      # we should probably list all of them
                      pushop.ui.warn(_('bookmark %s does not exist on the local '
                                       'or remote repository!\n') % explicit[0])
                      pushop.bkresult = 2
                  pushop.outbookmarks.sort()
              def _pushcheckoutgoing(pushop):
                  outgoing = pushop.outgoing
                  unfi = pushop.repo.unfiltered()
                  if not outgoing.missing:
                      # nothing to push
                      scmutil.nochangesfound(unfi.ui, unfi, outgoing.excluded)
                      return False
                  # something to push
                  if not pushop.force:
                      # if repo.obsstore == False --> no obsolete
                      # then, save the iteration
                      if unfi.obsstore:
                          # this message are here for 80 char limit reason
                          mso = _("push includes obsolete changeset: %s!")
                          mspd = _("push includes phase-divergent changeset: %s!")
                          mscd = _("push includes content-divergent changeset: %s!")
                          mst = {"orphan": _("push includes orphan changeset: %s!"),
                                 "phase-divergent": mspd,
                                 "content-divergent": mscd}
                          # If we are to push if there is at least one
                          # obsolete or unstable changeset in missing, at
                          # least one of the missinghead will be obsolete or
                          # unstable. So checking heads only is ok
                          for node in outgoing.missingheads:
                              ctx = unfi[node]
                              if ctx.obsolete():
                                  raise error.Abort(mso % ctx)
                              elif ctx.isunstable():
                                  # TODO print more than one instability in the abort
                                  # message
                                  raise error.Abort(mst[ctx.instabilities()[0]] % ctx)
                      discovery.checkheads(pushop)
                  return True
              # List of names of steps to perform for an outgoing bundle2, order matters.
              b2partsgenorder = []
              # Mapping between step name and function
              #
              # This exists to help extensions wrap steps if necessary
              b2partsgenmapping = {}
              def b2partsgenerator(stepname, idx=None):
                  """decorator for function generating bundle2 part
                  The function is added to the step -> function mapping and appended to the
                  list of steps.  Beware that decorated functions will be added in order
                  (this may matter).
                  You can only use this decorator for new steps, if you want to wrap a step
                  from an extension, attack the b2partsgenmapping dictionary directly."""
                  def dec(func):
                      assert stepname not in b2partsgenmapping
                      b2partsgenmapping[stepname] = func
                      if idx is None:
                          b2partsgenorder.append(stepname)
                      else:
                          b2partsgenorder.insert(idx, stepname)
                      return func
                  return dec
              def _pushb2ctxcheckheads(pushop, bundler):
                  """Generate race condition checking parts
                  Exists as an independent function to aid extensions
                  """
                  # * 'force' do not check for push race,
                  # * if we don't push anything, there are nothing to check.
                  if not pushop.force and pushop.outgoing.missingheads:
                      allowunrelated = 'related' in bundler.capabilities.get('checkheads', ())
                      emptyremote = pushop.pushbranchmap is None
                      if not allowunrelated or emptyremote:
                          bundler.newpart('check:heads', data=iter(pushop.remoteheads))
                      else:
                          affected = set()
                          for branch, heads in pushop.pushbranchmap.iteritems():
                              remoteheads, newheads, unsyncedheads, discardedheads = heads
                              if remoteheads is not None:
                                  remote = set(remoteheads)
                                  affected |= set(discardedheads) & remote
                                  affected |= remote - set(newheads)
                          if affected:
                              data = iter(sorted(affected))
                              bundler.newpart('check:updated-heads', data=data)
              def _pushing(pushop):
                  """return True if we are pushing anything"""
                  return bool(pushop.outgoing.missing
                              or pushop.outdatedphases
                              or pushop.outobsmarkers
                              or pushop.outbookmarks)
              @b2partsgenerator('check-bookmarks')
              def _pushb2checkbookmarks(pushop, bundler):
                  """insert bookmark move checking"""
                  if not _pushing(pushop) or pushop.force:
                      return
                  b2caps = bundle2.bundle2caps(pushop.remote)
                  hasbookmarkcheck = 'bookmarks' in b2caps
                  if not (pushop.outbookmarks and hasbookmarkcheck):
                      return
                  data = []
                  for book, old, new in pushop.outbookmarks:
                      old = bin(old)
                      data.append((book, old))
                  checkdata = bookmod.binaryencode(data)
                  bundler.newpart('check:bookmarks', data=checkdata)
              @b2partsgenerator('check-phases')
              def _pushb2checkphases(pushop, bundler):
                  """insert phase move checking"""
                  if not _pushing(pushop) or pushop.force:
                      return
                  b2caps = bundle2.bundle2caps(pushop.remote)
                  hasphaseheads = 'heads' in b2caps.get('phases', ())
                  if pushop.remotephases is not None and hasphaseheads:
                      # check that the remote phase has not changed
                      checks = [[] for p in phases.allphases]
                      checks[phases.public].extend(pushop.remotephases.publicheads)
                      checks[phases.draft].extend(pushop.remotephases.draftroots)
                      if any(checks):
                          for nodes in checks:
                              nodes.sort()
                          checkdata = phases.binaryencode(checks)
                          bundler.newpart('check:phases', data=checkdata)
              @b2partsgenerator('changeset')
              def _pushb2ctx(pushop, bundler):
                  """handle changegroup push through bundle2
                  addchangegroup result is stored in the ``pushop.cgresult`` attribute.
                  """
                  if 'changesets' in pushop.stepsdone:
                      return
                  pushop.stepsdone.add('changesets')
                  # Send known heads to the server for race detection.
                  if not _pushcheckoutgoing(pushop):
                      return
                  pushop.repo.prepushoutgoinghooks(pushop)
                  _pushb2ctxcheckheads(pushop, bundler)
                  b2caps = bundle2.bundle2caps(pushop.remote)
                  version = '01'
                  cgversions = b2caps.get('changegroup')
                  if cgversions:  # 3.1 and 3.2 ship with an empty value
                      cgversions = [v for v in cgversions
                                    if v in changegroup.supportedoutgoingversions(
                                        pushop.repo)]
                      if not cgversions:
                          raise error.Abort(_('no common changegroup version'))
                      version = max(cgversions)
                  cgstream = changegroup.makestream(pushop.repo, pushop.outgoing, version,
                                                    'push')
                  cgpart = bundler.newpart('changegroup', data=cgstream)
                  if cgversions:
                      cgpart.addparam('version', version)
                  if 'treemanifest' in pushop.repo.requirements:
                      cgpart.addparam('treemanifest', '1')
                  def handlereply(op):
                      """extract addchangegroup returns from server reply"""
                      cgreplies = op.records.getreplies(cgpart.id)
                      assert len(cgreplies['changegroup']) == 1
                      pushop.cgresult = cgreplies['changegroup'][0]['return']
                  return handlereply
              @b2partsgenerator('phase')
              def _pushb2phases(pushop, bundler):
                  """handle phase push through bundle2"""
                  if 'phases' in pushop.stepsdone:
                      return
                  b2caps = bundle2.bundle2caps(pushop.remote)
                  ui = pushop.repo.ui
                  legacyphase = 'phases' in ui.configlist('devel', 'legacy.exchange')
                  haspushkey = 'pushkey' in b2caps
                  hasphaseheads = 'heads' in b2caps.get('phases', ())
                  if hasphaseheads and not legacyphase:
                      return _pushb2phaseheads(pushop, bundler)
                  elif haspushkey:
                      return _pushb2phasespushkey(pushop, bundler)
              def _pushb2phaseheads(pushop, bundler):
                  """push phase information through a bundle2 - binary part"""
                  pushop.stepsdone.add('phases')
                  if pushop.outdatedphases:
                      updates = [[] for p in phases.allphases]
                      updates[0].extend(h.node() for h in pushop.outdatedphases)
                      phasedata = phases.binaryencode(updates)
                      bundler.newpart('phase-heads', data=phasedata)
              def _pushb2phasespushkey(pushop, bundler):
                  """push phase information through a bundle2 - pushkey part"""
                  pushop.stepsdone.add('phases')
                  part2node = []
                  def handlefailure(pushop, exc):
                      targetid = int(exc.partid)
                      for partid, node in part2node:
                          if partid == targetid:
                              raise error.Abort(_('updating %s to public failed') % node)
                  enc = pushkey.encode
                  for newremotehead in pushop.outdatedphases:
                      part = bundler.newpart('pushkey')
                      part.addparam('namespace', enc('phases'))
                      part.addparam('key', enc(newremotehead.hex()))
                      part.addparam('old', enc('%d' % phases.draft))
                      part.addparam('new', enc('%d' % phases.public))
                      part2node.append((part.id, newremotehead))
                      pushop.pkfailcb[part.id] = handlefailure
                  def handlereply(op):
                      for partid, node in part2node:
                          partrep = op.records.getreplies(partid)
                          results = partrep['pushkey']
                          assert len(results) <= 1
                          msg = None
                          if not results:
                              msg = _('server ignored update of %s to public!\n') % node
                          elif not int(results[0]['return']):
                              msg = _('updating %s to public failed!\n') % node
                          if msg is not None:
                              pushop.ui.warn(msg)
                  return handlereply
              @b2partsgenerator('obsmarkers')
              def _pushb2obsmarkers(pushop, bundler):
                  if 'obsmarkers' in pushop.stepsdone:
                      return
                  remoteversions = bundle2.obsmarkersversion(bundler.capabilities)
                  if obsolete.commonversion(remoteversions) is None:
                      return
                  pushop.stepsdone.add('obsmarkers')
                  if pushop.outobsmarkers:
                      markers = sorted(pushop.outobsmarkers)
                      bundle2.buildobsmarkerspart(bundler, markers)
              @b2partsgenerator('bookmarks')
              def _pushb2bookmarks(pushop, bundler):
                  """handle bookmark push through bundle2"""
                  if 'bookmarks' in pushop.stepsdone:
                      return
                  b2caps = bundle2.bundle2caps(pushop.remote)
                  legacy = pushop.repo.ui.configlist('devel', 'legacy.exchange')
                  legacybooks = 'bookmarks' in legacy
                  if not legacybooks and 'bookmarks' in b2caps:
                      return _pushb2bookmarkspart(pushop, bundler)
                  elif 'pushkey' in b2caps:
                      return _pushb2bookmarkspushkey(pushop, bundler)
              def _bmaction(old, new):
                  """small utility for bookmark pushing"""
                  if not old:
                      return 'export'
                  elif not new:
                      return 'delete'
                  return 'update'
              def _pushb2bookmarkspart(pushop, bundler):
                  pushop.stepsdone.add('bookmarks')
                  if not pushop.outbookmarks:
                      return
                  allactions = []
                  data = []
                  for book, old, new in pushop.outbookmarks:
                      new = bin(new)
                      data.append((book, new))
                      allactions.append((book, _bmaction(old, new)))
                  checkdata = bookmod.binaryencode(data)
                  bundler.newpart('bookmarks', data=checkdata)
                  def handlereply(op):
                      ui = pushop.ui
                      # if success
                      for book, action in allactions:
                          ui.status(bookmsgmap[action][0] % book)
                  return handlereply
              def _pushb2bookmarkspushkey(pushop, bundler):
                  pushop.stepsdone.add('bookmarks')
                  part2book = []
                  enc = pushkey.encode
                  def handlefailure(pushop, exc):
                      targetid = int(exc.partid)
                      for partid, book, action in part2book:
                          if partid == targetid:
                              raise error.Abort(bookmsgmap[action][1].rstrip() % book)
                      # we should not be called for part we did not generated
                      assert False
                  for book, old, new in pushop.outbookmarks:
                      part = bundler.newpart('pushkey')
                      part.addparam('namespace', enc('bookmarks'))
                      part.addparam('key', enc(book))
                      part.addparam('old', enc(old))
                      part.addparam('new', enc(new))
                      action = 'update'
                      if not old:
                          action = 'export'
                      elif not new:
                          action = 'delete'
                      part2book.append((part.id, book, action))
                      pushop.pkfailcb[part.id] = handlefailure
                  def handlereply(op):
                      ui = pushop.ui
                      for partid, book, action in part2book:
                          partrep = op.records.getreplies(partid)
                          results = partrep['pushkey']
                          assert len(results) <= 1
                          if not results:
                              pushop.ui.warn(_('server ignored bookmark %s update\n') % book)
                          else:
                              ret = int(results[0]['return'])
                              if ret:
                                  ui.status(bookmsgmap[action][0] % book)
                              else:
                                  ui.warn(bookmsgmap[action][1] % book)
                                  if pushop.bkresult is not None:
                                      pushop.bkresult = 1
                  return handlereply
              @b2partsgenerator('pushvars', idx=0)
              def _getbundlesendvars(pushop, bundler):
                  '''send shellvars via bundle2'''
                  pushvars = pushop.pushvars
                  if pushvars:
                      shellvars = {}
                      for raw in pushvars:
                          if '=' not in raw:
                              msg = ("unable to parse variable '%s', should follow "
                                      "'KEY=VALUE' or 'KEY=' format")
                              raise error.Abort(msg % raw)
                          k, v = raw.split('=', 1)
                          shellvars[k] = v
                      part = bundler.newpart('pushvars')
                      for key, value in shellvars.iteritems():
                          part.addparam(key, value, mandatory=False)
              def _pushbundle2(pushop):
                  """push data to the remote using bundle2
                  The only currently supported type of data is changegroup but this will
                  evolve in the future."""
                  bundler = bundle2.bundle20(pushop.ui, bundle2.bundle2caps(pushop.remote))
                  pushback = (pushop.trmanager
                              and pushop.ui.configbool('experimental', 'bundle2.pushback'))
                  # create reply capability
                  capsblob = bundle2.encodecaps(bundle2.getrepocaps(pushop.repo,
                                                                    allowpushback=pushback,
                                                                    role='client'))
                  bundler.newpart('replycaps', data=capsblob)
                  replyhandlers = []
                  for partgenname in b2partsgenorder:
                      partgen = b2partsgenmapping[partgenname]
                      ret = partgen(pushop, bundler)
                      if callable(ret):
                          replyhandlers.append(ret)
                  # do not push if nothing to push
                  if bundler.nbparts <= 1:
                      return
                  stream = util.chunkbuffer(bundler.getchunks())
                  try:
                      try:
                          with pushop.remote.commandexecutor() as e:
                              reply = e.callcommand('unbundle', {
                                  'bundle': stream,
                                  'heads': ['force'],
                                  'url': pushop.remote.url(),
                              }).result()
                      except error.BundleValueError as exc:
                          raise error.Abort(_('missing support for %s') % exc)
                      try:
                          trgetter = None
                          if pushback:
                              trgetter = pushop.trmanager.transaction
                          op = bundle2.processbundle(pushop.repo, reply, trgetter)
                      except error.BundleValueError as exc:
                          raise error.Abort(_('missing support for %s') % exc)
                      except bundle2.AbortFromPart as exc:
                          pushop.ui.status(_('remote: %s\n') % exc)
                          if exc.hint is not None:
                              pushop.ui.status(_('remote: %s\n') % ('(%s)' % exc.hint))
                          raise error.Abort(_('push failed on remote'))
                  except error.PushkeyFailed as exc:
                      partid = int(exc.partid)
                      if partid not in pushop.pkfailcb:
                          raise
                      pushop.pkfailcb[partid](pushop, exc)
                  for rephand in replyhandlers:
                      rephand(op)
              def _pushchangeset(pushop):
                  """Make the actual push of changeset bundle to remote repo"""
                  if 'changesets' in pushop.stepsdone:
                      return
                  pushop.stepsdone.add('changesets')
                  if not _pushcheckoutgoing(pushop):
                      return
                  # Should have verified this in push().
                  assert pushop.remote.capable('unbundle')
                  pushop.repo.prepushoutgoinghooks(pushop)
                  outgoing = pushop.outgoing
                  # TODO: get bundlecaps from remote
                  bundlecaps = None
                  # create a changegroup from local
                  if pushop.revs is None and not (outgoing.excluded
                                          or pushop.repo.changelog.filteredrevs):
                      # push everything,
                      # use the fast path, no race possible on push
                      cg = changegroup.makechangegroup(pushop.repo, outgoing, '01', 'push',
                              fastpath=True, bundlecaps=bundlecaps)
                  else:
                      cg = changegroup.makechangegroup(pushop.repo, outgoing, '01',
                                                      'push', bundlecaps=bundlecaps)
                  # apply changegroup to remote
                  # local repo finds heads on server, finds out what
                  # revs it must push. once revs transferred, if server
                  # finds it has different heads (someone else won
                  # commit/push race), server aborts.
                  if pushop.force:
                      remoteheads = ['force']
                  else:
                      remoteheads = pushop.remoteheads
                  # ssh: return remote's addchangegroup()
                  # http: return remote's addchangegroup() or 0 for error
                  pushop.cgresult = pushop.remote.unbundle(cg, remoteheads,
                                                      pushop.repo.url())
              def _pushsyncphase(pushop):
                  """synchronise phase information locally and remotely"""
                  cheads = pushop.commonheads
                  # even when we don't push, exchanging phase data is useful
                  remotephases = listkeys(pushop.remote, 'phases')
                  if (pushop.ui.configbool('ui', '_usedassubrepo')
                      and remotephases    # server supports phases
                      and pushop.cgresult is None # nothing was pushed
                      and remotephases.get('publishing', False)):
                      # When:
                      # - this is a subrepo push
                      # - and remote support phase
                      # - and no changeset was pushed
                      # - and remote is publishing
                      # We may be in issue 3871 case!
                      # We drop the possible phase synchronisation done by
                      # courtesy to publish changesets possibly locally draft
                      # on the remote.
                      remotephases = {'publishing': 'True'}
                  if not remotephases: # old server or public only reply from non-publishing
                      _localphasemove(pushop, cheads)
                      # don't push any phase data as there is nothing to push
                  else:
                      ana = phases.analyzeremotephases(pushop.repo, cheads,
                                                       remotephases)
                      pheads, droots = ana
                      ### Apply remote phase on local
                      if remotephases.get('publishing', False):
                          _localphasemove(pushop, cheads)
                      else: # publish = False
                          _localphasemove(pushop, pheads)
                          _localphasemove(pushop, cheads, phases.draft)
                      ### Apply local phase on remote
                      if pushop.cgresult:
                          if 'phases' in pushop.stepsdone:
                              # phases already pushed though bundle2
                              return
                          outdated = pushop.outdatedphases
                      else:
                          outdated = pushop.fallbackoutdatedphases
                      pushop.stepsdone.add('phases')
                      # filter heads already turned public by the push
                      outdated = [c for c in outdated if c.node() not in pheads]
                      # fallback to independent pushkey command
                      for newremotehead in outdated:
                          with pushop.remote.commandexecutor() as e:
                              r = e.callcommand('pushkey', {
                                  'namespace': 'phases',
                                  'key': newremotehead.hex(),
                                  'old': '%d' % phases.draft,
                                  'new': '%d' % phases.public
                              }).result()
                          if not r:
                              pushop.ui.warn(_('updating %s to public failed!\n')
                                             % newremotehead)
              def _localphasemove(pushop, nodes, phase=phases.public):
                  """move <nodes> to <phase> in the local source repo"""
                  if pushop.trmanager:
                      phases.advanceboundary(pushop.repo,
                                             pushop.trmanager.transaction(),
                                             phase,
                                             nodes)
                  else:
                      # repo is not locked, do not change any phases!
                      # Informs the user that phases should have been moved when
                      # applicable.
                      actualmoves = [n for n in nodes if phase < pushop.repo[n].phase()]
                      phasestr = phases.phasenames[phase]
                      if actualmoves:
                          pushop.ui.status(_('cannot lock source repo, skipping '
                                             'local %s phase update\n') % phasestr)
              def _pushobsolete(pushop):
                  """utility function to push obsolete markers to a remote"""
                  if 'obsmarkers' in pushop.stepsdone:
                      return
                  repo = pushop.repo
                  remote = pushop.remote
                  pushop.stepsdone.add('obsmarkers')
                  if pushop.outobsmarkers:
                      pushop.ui.debug('try to push obsolete markers to remote\n')
                      rslts = []
                      remotedata = obsolete._pushkeyescape(sorted(pushop.outobsmarkers))
                      for key in sorted(remotedata, reverse=True):
                          # reverse sort to ensure we end with dump0
                          data = remotedata[key]
                          rslts.append(remote.pushkey('obsolete', key, '', data))
                      if [r for r in rslts if not r]:
                          msg = _('failed to push some obsolete markers!\n')
                          repo.ui.warn(msg)
              def _pushbookmark(pushop):
                  """Update bookmark position on remote"""
                  if pushop.cgresult == 0 or 'bookmarks' in pushop.stepsdone:
                      return
                  pushop.stepsdone.add('bookmarks')
                  ui = pushop.ui
                  remote = pushop.remote
                  for b, old, new in pushop.outbookmarks:
                      action = 'update'
                      if not old:
                          action = 'export'
                      elif not new:
                          action = 'delete'
                      with remote.commandexecutor() as e:
                          r = e.callcommand('pushkey', {
                              'namespace': 'bookmarks',
                              'key': b,
                              'old': old,
                              'new': new,
                          }).result()
                      if r:
                          ui.status(bookmsgmap[action][0] % b)
                      else:
                          ui.warn(bookmsgmap[action][1] % b)
                          # discovery can have set the value form invalid entry
                          if pushop.bkresult is not None:
                              pushop.bkresult = 1
              class pulloperation(object):
                  """A object that represent a single pull operation
                  It purpose is to carry pull related state and very common operation.
                  A new should be created at the beginning of each pull and discarded
                  afterward.
                  """
                  def __init__(self, repo, remote, heads=None, force=False, bookmarks=(),
                               remotebookmarks=None, streamclonerequested=None,
                               includepats=None, excludepats=None, depth=None):
                      # repo we pull into
                      self.repo = repo
                      # repo we pull from
                      self.remote = remote
                      # revision we try to pull (None is "all")
                      self.heads = heads
                      # bookmark pulled explicitly
                      self.explicitbookmarks = [repo._bookmarks.expandname(bookmark)
                                                for bookmark in bookmarks]
                      # do we force pull?
                      self.force = force
                      # whether a streaming clone was requested
                      self.streamclonerequested = streamclonerequested
                      # transaction manager
                      self.trmanager = None
                      # set of common changeset between local and remote before pull
                      self.common = None
                      # set of pulled head
                      self.rheads = None
                      # list of missing changeset to fetch remotely
                      self.fetch = None
                      # remote bookmarks data
                      self.remotebookmarks = remotebookmarks
                      # result of changegroup pulling (used as return code by pull)
                      self.cgresult = None
                      # list of step already done
                      self.stepsdone = set()
                      # Whether we attempted a clone from pre-generated bundles.
                      self.clonebundleattempted = False
                      # Set of file patterns to include.
                      self.includepats = includepats
                      # Set of file patterns to exclude.
                      self.excludepats = excludepats
                      # Number of ancestor changesets to pull from each pulled head.
                      self.depth = depth
                  @util.propertycache
                  def pulledsubset(self):
                      """heads of the set of changeset target by the pull"""
                      # compute target subset
                      if self.heads is None:
                          # We pulled every thing possible
                          # sync on everything common
                          c = set(self.common)
                          ret = list(self.common)
                          for n in self.rheads:
                              if n not in c:
                                  ret.append(n)
                          return ret
                      else:
                          # We pulled a specific subset
                          # sync on this subset
                          return self.heads
                  @util.propertycache
                  def canusebundle2(self):
                      return not _forcebundle1(self)
                  @util.propertycache
                  def remotebundle2caps(self):
                      return bundle2.bundle2caps(self.remote)
                  def gettransaction(self):
                      # deprecated; talk to trmanager directly
                      return self.trmanager.transaction()
              class transactionmanager(util.transactional):
                  """An object to manage the life cycle of a transaction
                  It creates the transaction on demand and calls the appropriate hooks when
                  closing the transaction."""
                  def __init__(self, repo, source, url):
                      self.repo = repo
                      self.source = source
                      self.url = url
                      self._tr = None
                  def transaction(self):
                      """Return an open transaction object, constructing if necessary"""
                      if not self._tr:
                          trname = '%s\n%s' % (self.source, util.hidepassword(self.url))
                          self._tr = self.repo.transaction(trname)
                          self._tr.hookargs['source'] = self.source
                          self._tr.hookargs['url'] = self.url
                      return self._tr
                  def close(self):
                      """close transaction if created"""
                      if self._tr is not None:
                          self._tr.close()
                  def release(self):
                      """release transaction if created"""
                      if self._tr is not None:
                          self._tr.release()
              def listkeys(remote, namespace):
                  with remote.commandexecutor() as e:
                      return e.callcommand('listkeys', {'namespace': namespace}).result()
              def _fullpullbundle2(repo, pullop):
                  # The server may send a partial reply, i.e. when inlining
                  # pre-computed bundles. In that case, update the common
                  # set based on the results and pull another bundle.
                  #
                  # There are two indicators that the process is finished:
                  # - no changeset has been added, or
                  # - all remote heads are known locally.
                  # The head check must use the unfiltered view as obsoletion
                  # markers can hide heads.
                  unfi = repo.unfiltered()
                  unficl = unfi.changelog
                  def headsofdiff(h1, h2):
                      """Returns heads(h1 % h2)"""
                      res = unfi.set('heads(%ln %% %ln)', h1, h2)
                      return set(ctx.node() for ctx in res)
                  def headsofunion(h1, h2):
                      """Returns heads((h1 + h2) - null)"""
                      res = unfi.set('heads((%ln + %ln - null))', h1, h2)
                      return set(ctx.node() for ctx in res)
                  while True:
                      old_heads = unficl.heads()
                      clstart = len(unficl)
                      _pullbundle2(pullop)
                      if repository.NARROW_REQUIREMENT in repo.requirements:
                          # XXX narrow clones filter the heads on the server side during
                          # XXX getbundle and result in partial replies as well.
                          # XXX Disable pull bundles in this case as band aid to avoid
                          # XXX extra round trips.
                          break
                      if clstart == len(unficl):
                          break
                      if all(unficl.hasnode(n) for n in pullop.rheads):
                          break
                      new_heads = headsofdiff(unficl.heads(), old_heads)
                      pullop.common = headsofunion(new_heads, pullop.common)
                      pullop.rheads = set(pullop.rheads) - pullop.common
              def pull(repo, remote, heads=None, force=False, bookmarks=(), opargs=None,
                       streamclonerequested=None, includepats=None, excludepats=None,
                       depth=None):
                  """Fetch repository data from a remote.
                  This is the main function used to retrieve data from a remote repository.
                  ``repo`` is the local repository to clone into.
                  ``remote`` is a peer instance.
                  ``heads`` is an iterable of revisions we want to pull. ``None`` (the
                  default) means to pull everything from the remote.
                  ``bookmarks`` is an iterable of bookmarks requesting to be pulled. By
                  default, all remote bookmarks are pulled.
                  ``opargs`` are additional keyword arguments to pass to ``pulloperation``
                  initialization.
                  ``streamclonerequested`` is a boolean indicating whether a "streaming
                  clone" is requested. A "streaming clone" is essentially a raw file copy
                  of revlogs from the server. This only works when the local repository is
                  empty. The default value of ``None`` means to respect the server
                  configuration for preferring stream clones.
                  ``includepats`` and ``excludepats`` define explicit file patterns to
                  include and exclude in storage, respectively. If not defined, narrow
                  patterns from the repo instance are used, if available.
                  ``depth`` is an integer indicating the DAG depth of history we're
                  interested in. If defined, for each revision specified in ``heads``, we
                  will fetch up to this many of its ancestors and data associated with them.
                  Returns the ``pulloperation`` created for this pull.
                  """
                  if opargs is None:
                      opargs = {}
                  # We allow the narrow patterns to be passed in explicitly to provide more
                  # flexibility for API consumers.
                  if includepats or excludepats:
                      includepats = includepats or set()
                      excludepats = excludepats or set()
                  else:
                      includepats, excludepats = repo.narrowpats
                  narrowspec.validatepatterns(includepats)
                  narrowspec.validatepatterns(excludepats)
                  pullop = pulloperation(repo, remote, heads, force, bookmarks=bookmarks,
                                         streamclonerequested=streamclonerequested,
                                         includepats=includepats, excludepats=excludepats,
                                         depth=depth,
                                         **pycompat.strkwargs(opargs))
                  peerlocal = pullop.remote.local()
                  if peerlocal:
                      missing = set(peerlocal.requirements) - pullop.repo.supported
                      if missing:
                          msg = _("required features are not"
                                  " supported in the destination:"
                                  " %s") % (', '.join(sorted(missing)))
                          raise error.Abort(msg)
                  pullop.trmanager = transactionmanager(repo, 'pull', remote.url())
                  with repo.wlock(), repo.lock(), pullop.trmanager:
                      # Use the modern wire protocol, if available.
                      if remote.capable('command-changesetdata'):
                          exchangev2.pull(pullop)
                      else:
                          # This should ideally be in _pullbundle2(). However, it needs to run
                          # before discovery to avoid extra work.
                          _maybeapplyclonebundle(pullop)
                          streamclone.maybeperformlegacystreamclone(pullop)
                          _pulldiscovery(pullop)
                          if pullop.canusebundle2:
                              _fullpullbundle2(repo, pullop)
                          _pullchangeset(pullop)
                          _pullphase(pullop)
                          _pullbookmarks(pullop)
                          _pullobsolete(pullop)
                  # storing remotenames
                  if repo.ui.configbool('experimental', 'remotenames'):
                      logexchange.pullremotenames(repo, remote)
                  return pullop
              # list of steps to perform discovery before pull
              pulldiscoveryorder = []
              # Mapping between step name and function
              #
              # This exists to help extensions wrap steps if necessary
              pulldiscoverymapping = {}
              def pulldiscovery(stepname):
                  """decorator for function performing discovery before pull
                  The function is added to the step -> function mapping and appended to the
                  list of steps.  Beware that decorated function will be added in order (this
                  may matter).
                  You can only use this decorator for a new step, if you want to wrap a step
                  from an extension, change the pulldiscovery dictionary directly."""
                  def dec(func):
                      assert stepname not in pulldiscoverymapping
                      pulldiscoverymapping[stepname] = func
                      pulldiscoveryorder.append(stepname)
                      return func
                  return dec
              def _pulldiscovery(pullop):
                  """Run all discovery steps"""
                  for stepname in pulldiscoveryorder:
                      step = pulldiscoverymapping[stepname]
                      step(pullop)
              @pulldiscovery('b1:bookmarks')
              def _pullbookmarkbundle1(pullop):
                  """fetch bookmark data in bundle1 case
                  If not using bundle2, we have to fetch bookmarks before changeset
                  discovery to reduce the chance and impact of race conditions."""
                  if pullop.remotebookmarks is not None:
                      return
                  if pullop.canusebundle2 and 'listkeys' in pullop.remotebundle2caps:
                      # all known bundle2 servers now support listkeys, but lets be nice with
                      # new implementation.
                      return
                  books = listkeys(pullop.remote, 'bookmarks')
                  pullop.remotebookmarks = bookmod.unhexlifybookmarks(books)
              @pulldiscovery('changegroup')
              def _pulldiscoverychangegroup(pullop):
                  """discovery phase for the pull
                  Current handle changeset discovery only, will change handle all discovery
                  at some point."""
                  tmp = discovery.findcommonincoming(pullop.repo,
                                                     pullop.remote,
                                                     heads=pullop.heads,
                                                     force=pullop.force)
                  common, fetch, rheads = tmp
                  nm = pullop.repo.unfiltered().changelog.nodemap
                  if fetch and rheads:
                      # If a remote heads is filtered locally, put in back in common.
                      #
                      # This is a hackish solution to catch most of "common but locally
                      # hidden situation".  We do not performs discovery on unfiltered
                      # repository because it end up doing a pathological amount of round
                      # trip for w huge amount of changeset we do not care about.
                      #
                      # If a set of such "common but filtered" changeset exist on the server
                      # but are not including a remote heads, we'll not be able to detect it,
                      scommon = set(common)
                      for n in rheads:
                          if n in nm:
                              if n not in scommon:
                                  common.append(n)
                      if set(rheads).issubset(set(common)):
                          fetch = []
                  pullop.common = common
                  pullop.fetch = fetch
                  pullop.rheads = rheads
              def _pullbundle2(pullop):
                  """pull data using bundle2
                  For now, the only supported data are changegroup."""
                  kwargs = {'bundlecaps': caps20to10(pullop.repo, role='client')}
                  # make ui easier to access
                  ui = pullop.repo.ui
                  # At the moment we don't do stream clones over bundle2. If that is
                  # implemented then here's where the check for that will go.
                  streaming = streamclone.canperformstreamclone(pullop, bundle2=True)[0]
                  # declare pull perimeters
                  kwargs['common'] = pullop.common
                  kwargs['heads'] = pullop.heads or pullop.rheads
                  # check server supports narrow and then adding includepats and excludepats
                  servernarrow = pullop.remote.capable(wireprototypes.NARROWCAP)
                  if servernarrow and pullop.includepats:
                      kwargs['includepats'] = pullop.includepats
                  if servernarrow and pullop.excludepats:
                      kwargs['excludepats'] = pullop.excludepats
                  if streaming:
                      kwargs['cg'] = False
                      kwargs['stream'] = True
                      pullop.stepsdone.add('changegroup')
                      pullop.stepsdone.add('phases')
                  else:
                      # pulling changegroup
                      pullop.stepsdone.add('changegroup')
                      kwargs['cg'] = pullop.fetch
                      legacyphase = 'phases' in ui.configlist('devel', 'legacy.exchange')
                      hasbinaryphase = 'heads' in pullop.remotebundle2caps.get('phases', ())
                      if (not legacyphase and hasbinaryphase):
                          kwargs['phases'] = True
                          pullop.stepsdone.add('phases')
                      if 'listkeys' in pullop.remotebundle2caps:
                          if 'phases' not in pullop.stepsdone:
                              kwargs['listkeys'] = ['phases']
                  bookmarksrequested = False
                  legacybookmark = 'bookmarks' in ui.configlist('devel', 'legacy.exchange')
                  hasbinarybook = 'bookmarks' in pullop.remotebundle2caps
                  if pullop.remotebookmarks is not None:
                      pullop.stepsdone.add('request-bookmarks')
                  if ('request-bookmarks' not in pullop.stepsdone
                      and pullop.remotebookmarks is None
                      and not legacybookmark and hasbinarybook):
                      kwargs['bookmarks'] = True
                      bookmarksrequested = True
                  if 'listkeys' in pullop.remotebundle2caps:
                      if 'request-bookmarks' not in pullop.stepsdone:
                          # make sure to always includes bookmark data when migrating
                          # `hg incoming --bundle` to using this function.
                          pullop.stepsdone.add('request-bookmarks')
                          kwargs.setdefault('listkeys', []).append('bookmarks')
                  # If this is a full pull / clone and the server supports the clone bundles
                  # feature, tell the server whether we attempted a clone bundle. The
                  # presence of this flag indicates the client supports clone bundles. This
                  # will enable the server to treat clients that support clone bundles
                  # differently from those that don't.
                  if (pullop.remote.capable('clonebundles')
                      and pullop.heads is None and list(pullop.common) == [nullid]):
                      kwargs['cbattempted'] = pullop.clonebundleattempted
                  if streaming:
                      pullop.repo.ui.status(_('streaming all changes\n'))
                  elif not pullop.fetch:
                      pullop.repo.ui.status(_("no changes found\n"))
                      pullop.cgresult = 0
                  else:
                      if pullop.heads is None and list(pullop.common) == [nullid]:
                          pullop.repo.ui.status(_("requesting all changes\n"))
                  if obsolete.isenabled(pullop.repo, obsolete.exchangeopt):
                      remoteversions = bundle2.obsmarkersversion(pullop.remotebundle2caps)
                      if obsolete.commonversion(remoteversions) is not None:
                          kwargs['obsmarkers'] = True
                          pullop.stepsdone.add('obsmarkers')
                  _pullbundle2extraprepare(pullop, kwargs)
                  with pullop.remote.commandexecutor() as e:
                      args = dict(kwargs)
                      args['source'] = 'pull'
                      bundle = e.callcommand('getbundle', args).result()
                      try:
                          op = bundle2.bundleoperation(pullop.repo, pullop.gettransaction,
                                                       source='pull')
                          op.modes['bookmarks'] = 'records'
                          bundle2.processbundle(pullop.repo, bundle, op=op)
                      except bundle2.AbortFromPart as exc:
                          pullop.repo.ui.status(_('remote: abort: %s\n') % exc)
                          raise error.Abort(_('pull failed on remote'), hint=exc.hint)
                      except error.BundleValueError as exc:
                          raise error.Abort(_('missing support for %s') % exc)
                  if pullop.fetch:
                      pullop.cgresult = bundle2.combinechangegroupresults(op)
                  # processing phases change
                  for namespace, value in op.records['listkeys']:
                      if namespace == 'phases':
                          _pullapplyphases(pullop, value)
                  # processing bookmark update
                  if bookmarksrequested:
                      books = {}
                      for record in op.records['bookmarks']:
                          books[record['bookmark']] = record["node"]
                      pullop.remotebookmarks = books
                  else:
                      for namespace, value in op.records['listkeys']:
                          if namespace == 'bookmarks':
                              pullop.remotebookmarks = bookmod.unhexlifybookmarks(value)
                  # bookmark data were either already there or pulled in the bundle
                  if pullop.remotebookmarks is not None:
                      _pullbookmarks(pullop)
              def _pullbundle2extraprepare(pullop, kwargs):
                  """hook function so that extensions can extend the getbundle call"""
              def _pullchangeset(pullop):
                  """pull changeset from unbundle into the local repo"""
                  # We delay the open of the transaction as late as possible so we
                  # don't open transaction for nothing or you break future useful
                  # rollback call
                  if 'changegroup' in pullop.stepsdone:
                      return
                  pullop.stepsdone.add('changegroup')
                  if not pullop.fetch:
                      pullop.repo.ui.status(_("no changes found\n"))
                      pullop.cgresult = 0
                      return
                  tr = pullop.gettransaction()
                  if pullop.heads is None and list(pullop.common) == [nullid]:
                      pullop.repo.ui.status(_("requesting all changes\n"))
                  elif pullop.heads is None and pullop.remote.capable('changegroupsubset'):
                      # issue1320, avoid a race if remote changed after discovery
                      pullop.heads = pullop.rheads
                  if pullop.remote.capable('getbundle'):
                      # TODO: get bundlecaps from remote
                      cg = pullop.remote.getbundle('pull', common=pullop.common,
                                                   heads=pullop.heads or pullop.rheads)
                  elif pullop.heads is None:
                      with pullop.remote.commandexecutor() as e:
                          cg = e.callcommand('changegroup', {
                              'nodes': pullop.fetch,
                              'source': 'pull',
                          }).result()
                  elif not pullop.remote.capable('changegroupsubset'):
                      raise error.Abort(_("partial pull cannot be done because "
                                         "other repository doesn't support "
                                         "changegroupsubset."))
                  else:
                      with pullop.remote.commandexecutor() as e:
                          cg = e.callcommand('changegroupsubset', {
                              'bases': pullop.fetch,
                              'heads': pullop.heads,
                              'source': 'pull',
                          }).result()
                  bundleop = bundle2.applybundle(pullop.repo, cg, tr, 'pull',
                                                 pullop.remote.url())
                  pullop.cgresult = bundle2.combinechangegroupresults(bundleop)
              def _pullphase(pullop):
                  # Get remote phases data from remote
                  if 'phases' in pullop.stepsdone:
                      return
                  remotephases = listkeys(pullop.remote, 'phases')
                  _pullapplyphases(pullop, remotephases)
              def _pullapplyphases(pullop, remotephases):
                  """apply phase movement from observed remote state"""
                  if 'phases' in pullop.stepsdone:
                      return
                  pullop.stepsdone.add('phases')
                  publishing = bool(remotephases.get('publishing', False))
                  if remotephases and not publishing:
                      # remote is new and non-publishing
                      pheads, _dr = phases.analyzeremotephases(pullop.repo,
                                                               pullop.pulledsubset,
                                                               remotephases)
                      dheads = pullop.pulledsubset
                  else:
                      # Remote is old or publishing all common changesets
                      # should be seen as public
                      pheads = pullop.pulledsubset
                      dheads = []
                  unfi = pullop.repo.unfiltered()
                  phase = unfi._phasecache.phase
                  rev = unfi.changelog.nodemap.get
                  public = phases.public
                  draft = phases.draft
                  # exclude changesets already public locally and update the others
                  pheads = [pn for pn in pheads if phase(unfi, rev(pn)) > public]
                  if pheads:
                      tr = pullop.gettransaction()
                      phases.advanceboundary(pullop.repo, tr, public, pheads)
                  # exclude changesets already draft locally and update the others
                  dheads = [pn for pn in dheads if phase(unfi, rev(pn)) > draft]
                  if dheads:
                      tr = pullop.gettransaction()
                      phases.advanceboundary(pullop.repo, tr, draft, dheads)
              def _pullbookmarks(pullop):
                  """process the remote bookmark information to update the local one"""
                  if 'bookmarks' in pullop.stepsdone:
                      return
                  pullop.stepsdone.add('bookmarks')
                  repo = pullop.repo
                  remotebookmarks = pullop.remotebookmarks
                  bookmod.updatefromremote(repo.ui, repo, remotebookmarks,
                                           pullop.remote.url(),
                                           pullop.gettransaction,
                                           explicit=pullop.explicitbookmarks)
              def _pullobsolete(pullop):
                  """utility function to pull obsolete markers from a remote
                  The `gettransaction` is function that return the pull transaction, creating
                  one if necessary. We return the transaction to inform the calling code that
                  a new transaction have been created (when applicable).
                  Exists mostly to allow overriding for experimentation purpose"""
                  if 'obsmarkers' in pullop.stepsdone:
                      return
                  pullop.stepsdone.add('obsmarkers')
                  tr = None
                  if obsolete.isenabled(pullop.repo, obsolete.exchangeopt):
                      pullop.repo.ui.debug('fetching remote obsolete markers\n')
                      remoteobs = listkeys(pullop.remote, 'obsolete')
                      if 'dump0' in remoteobs:
                          tr = pullop.gettransaction()
                          markers = []
                          for key in sorted(remoteobs, reverse=True):
                              if key.startswith('dump'):
                                  data = util.b85decode(remoteobs[key])
                                  version, newmarks = obsolete._readmarkers(data)
                                  markers += newmarks
                          if markers:
                              pullop.repo.obsstore.add(tr, markers)
                          pullop.repo.invalidatevolatilesets()
                  return tr
              def applynarrowacl(repo, kwargs):
                  """Apply narrow fetch access control.
                  This massages the named arguments for getbundle wire protocol commands
                  so requested data is filtered through access control rules.
                  """
                  ui = repo.ui
                  # TODO this assumes existence of HTTP and is a layering violation.
                  username = ui.shortuser(ui.environ.get('REMOTE_USER') or ui.username())
                  user_includes = ui.configlist(
                      _NARROWACL_SECTION, username + '.includes',
                      ui.configlist(_NARROWACL_SECTION, 'default.includes'))
                  user_excludes = ui.configlist(
                      _NARROWACL_SECTION, username + '.excludes',
                      ui.configlist(_NARROWACL_SECTION, 'default.excludes'))
                  if not user_includes:
                      raise error.Abort(_("{} configuration for user {} is empty")
                                        .format(_NARROWACL_SECTION, username))
                  user_includes = [
                      'path:.' if p == '*' else 'path:' + p for p in user_includes]
                  user_excludes = [
                      'path:.' if p == '*' else 'path:' + p for p in user_excludes]
                  req_includes = set(kwargs.get(r'includepats', []))
                  req_excludes = set(kwargs.get(r'excludepats', []))
                  req_includes, req_excludes, invalid_includes = narrowspec.restrictpatterns(
                      req_includes, req_excludes, user_includes, user_excludes)
                  if invalid_includes:
                      raise error.Abort(
                          _("The following includes are not accessible for {}: {}")
                          .format(username, invalid_includes))
                  new_args = {}
                  new_args.update(kwargs)
                  new_args[r'narrow'] = True
                  new_args[r'narrow_acl'] = True
                  new_args[r'includepats'] = req_includes
                  if req_excludes:
                      new_args[r'excludepats'] = req_excludes
                  return new_args
              def _computeellipsis(repo, common, heads, known, match, depth=None):
                  """Compute the shape of a narrowed DAG.
                  Args:
                    repo: The repository we're transferring.
                    common: The roots of the DAG range we're transferring.
                            May be just [nullid], which means all ancestors of heads.
                    heads: The heads of the DAG range we're transferring.
                    match: The narrowmatcher that allows us to identify relevant changes.
                    depth: If not None, only consider nodes to be full nodes if they are at
                           most depth changesets away from one of heads.
                  Returns:
                    A tuple of (visitnodes, relevant_nodes, ellipsisroots) where:
                      visitnodes: The list of nodes (either full or ellipsis) which
                                  need to be sent to the client.
                      relevant_nodes: The set of changelog nodes which change a file inside
                               the narrowspec. The client needs these as non-ellipsis nodes.
                      ellipsisroots: A dict of {rev: parents} that is used in
                                     narrowchangegroup to produce ellipsis nodes with the
                                     correct parents.
                  """
                  cl = repo.changelog
                  mfl = repo.manifestlog
                  clrev = cl.rev
                  commonrevs = {clrev(n) for n in common} | {nullrev}
                  headsrevs = {clrev(n) for n in heads}
                  if depth:
                      revdepth = {h: 0 for h in headsrevs}
                  ellipsisheads = collections.defaultdict(set)
                  ellipsisroots = collections.defaultdict(set)
                  def addroot(head, curchange):
                      """Add a root to an ellipsis head, splitting heads with 3 roots."""
                      ellipsisroots[head].add(curchange)
                      # Recursively split ellipsis heads with 3 roots by finding the
                      # roots' youngest common descendant which is an elided merge commit.
                      # That descendant takes 2 of the 3 roots as its own, and becomes a
                      # root of the head.
                      while len(ellipsisroots[head]) > 2:
                          child, roots = splithead(head)
                          splitroots(head, child, roots)
                          head = child  # Recurse in case we just added a 3rd root
                  def splitroots(head, child, roots):
                      ellipsisroots[head].difference_update(roots)
                      ellipsisroots[head].add(child)
                      ellipsisroots[child].update(roots)
                      ellipsisroots[child].discard(child)
                  def splithead(head):
                      r1, r2, r3 = sorted(ellipsisroots[head])
                      for nr1, nr2 in ((r2, r3), (r1, r3), (r1, r2)):
                          mid = repo.revs('sort(merge() & %d::%d & %d::%d, -rev)',
                                          nr1, head, nr2, head)
                          for j in mid:
                              if j == nr2:
                                  return nr2, (nr1, nr2)
                              if j not in ellipsisroots or len(ellipsisroots[j]) < 2:
                                  return j, (nr1, nr2)
                      raise error.Abort(_('Failed to split up ellipsis node! head: %d, '
                                          'roots: %d %d %d') % (head, r1, r2, r3))
                  missing = list(cl.findmissingrevs(common=commonrevs, heads=headsrevs))
                  visit = reversed(missing)
                  relevant_nodes = set()
                  visitnodes = [cl.node(m) for m in missing]
                  required = set(headsrevs) | known
                  for rev in visit:
                      clrev = cl.changelogrevision(rev)
                      ps = [prev for prev in cl.parentrevs(rev) if prev != nullrev]
                      if depth is not None:
                          curdepth = revdepth[rev]
                          for p in ps:
                              revdepth[p] = min(curdepth + 1, revdepth.get(p, depth + 1))
                      needed = False
                      shallow_enough = depth is None or revdepth[rev] <= depth
                      if shallow_enough:
                          curmf = mfl[clrev.manifest].read()
                          if ps:
                              # We choose to not trust the changed files list in
                              # changesets because it's not always correct. TODO: could
                              # we trust it for the non-merge case?
                              p1mf = mfl[cl.changelogrevision(ps[0]).manifest].read()
                              needed = bool(curmf.diff(p1mf, match))
                              if not needed and len(ps) > 1:
                                  # For merge changes, the list of changed files is not
                                  # helpful, since we need to emit the merge if a file
                                  # in the narrow spec has changed on either side of the
                                  # merge. As a result, we do a manifest diff to check.
                                  p2mf = mfl[cl.changelogrevision(ps[1]).manifest].read()
                                  needed = bool(curmf.diff(p2mf, match))
                          else:
                              # For a root node, we need to include the node if any
                              # files in the node match the narrowspec.
                              needed = any(curmf.walk(match))
                      if needed:
                          for head in ellipsisheads[rev]:
                              addroot(head, rev)
                          for p in ps:
                              required.add(p)
                          relevant_nodes.add(cl.node(rev))
                      else:
                          if not ps:
                              ps = [nullrev]
                          if rev in required:
                              for head in ellipsisheads[rev]:
                                  addroot(head, rev)
                              for p in ps:
                                  ellipsisheads[p].add(rev)
                          else:
                              for p in ps:
                                  ellipsisheads[p] |= ellipsisheads[rev]
                  # add common changesets as roots of their reachable ellipsis heads
                  for c in commonrevs:
                      for head in ellipsisheads[c]:
                          addroot(head, c)
                  return visitnodes, relevant_nodes, ellipsisroots
              def caps20to10(repo, role):
                  """return a set with appropriate options to use bundle20 during getbundle"""
                  caps = {'HG20'}
                  capsblob = bundle2.encodecaps(bundle2.getrepocaps(repo, role=role))
                  caps.add('bundle2=' + urlreq.quote(capsblob))
                  return caps
              # List of names of steps to perform for a bundle2 for getbundle, order matters.
              getbundle2partsorder = []
              # Mapping between step name and function
              #
              # This exists to help extensions wrap steps if necessary
              getbundle2partsmapping = {}
              def getbundle2partsgenerator(stepname, idx=None):
                  """decorator for function generating bundle2 part for getbundle
                  The function is added to the step -> function mapping and appended to the
                  list of steps.  Beware that decorated functions will be added in order
                  (this may matter).
                  You can only use this decorator for new steps, if you want to wrap a step
                  from an extension, attack the getbundle2partsmapping dictionary directly."""
                  def dec(func):
                      assert stepname not in getbundle2partsmapping
                      getbundle2partsmapping[stepname] = func
                      if idx is None:
                          getbundle2partsorder.append(stepname)
                      else:
                          getbundle2partsorder.insert(idx, stepname)
                      return func
                  return dec
              def bundle2requested(bundlecaps):
                  if bundlecaps is not None:
                      return any(cap.startswith('HG2') for cap in bundlecaps)
                  return False
              def getbundlechunks(repo, source, heads=None, common=None, bundlecaps=None,
                                  **kwargs):
                  """Return chunks constituting a bundle's raw data.
                  Could be a bundle HG10 or a bundle HG20 depending on bundlecaps
                  passed.
                  Returns a 2-tuple of a dict with metadata about the generated bundle
                  and an iterator over raw chunks (of varying sizes).
                  """
                  kwargs = pycompat.byteskwargs(kwargs)
                  info = {}
                  usebundle2 = bundle2requested(bundlecaps)
                  # bundle10 case
                  if not usebundle2:
                      if bundlecaps and not kwargs.get('cg', True):
                          raise ValueError(_('request for bundle10 must include changegroup'))
                      if kwargs:
                          raise ValueError(_('unsupported getbundle arguments: %s')
                                           % ', '.join(sorted(kwargs.keys())))
                      outgoing = _computeoutgoing(repo, heads, common)
                      info['bundleversion'] = 1
                      return info, changegroup.makestream(repo, outgoing, '01', source,
                                                          bundlecaps=bundlecaps)
                  # bundle20 case
                  info['bundleversion'] = 2
                  b2caps = {}
                  for bcaps in bundlecaps:
                      if bcaps.startswith('bundle2='):
                          blob = urlreq.unquote(bcaps[len('bundle2='):])
                          b2caps.update(bundle2.decodecaps(blob))
                  bundler = bundle2.bundle20(repo.ui, b2caps)
                  kwargs['heads'] = heads
                  kwargs['common'] = common
                  for name in getbundle2partsorder:
                      func = getbundle2partsmapping[name]
                      func(bundler, repo, source, bundlecaps=bundlecaps, b2caps=b2caps,
                           **pycompat.strkwargs(kwargs))
                  info['prefercompressed'] = bundler.prefercompressed
                  return info, bundler.getchunks()
              @getbundle2partsgenerator('stream2')
              def _getbundlestream2(bundler, repo, *args, **kwargs):
                  return bundle2.addpartbundlestream2(bundler, repo, **kwargs)
              @getbundle2partsgenerator('changegroup')
              def _getbundlechangegrouppart(bundler, repo, source, bundlecaps=None,
                                            b2caps=None, heads=None, common=None, **kwargs):
                  """add a changegroup part to the requested bundle"""
                  if not kwargs.get(r'cg', True):
                      return
                  version = '01'
                  cgversions = b2caps.get('changegroup')
                  if cgversions:  # 3.1 and 3.2 ship with an empty value
                      cgversions = [v for v in cgversions
                                    if v in changegroup.supportedoutgoingversions(repo)]
                      if not cgversions:
                          raise error.Abort(_('no common changegroup version'))
                      version = max(cgversions)
                  outgoing = _computeoutgoing(repo, heads, common)
                  if not outgoing.missing:
                      return
                  if kwargs.get(r'narrow', False):
                      include = sorted(filter(bool, kwargs.get(r'includepats', [])))
                      exclude = sorted(filter(bool, kwargs.get(r'excludepats', [])))
                      matcher = narrowspec.match(repo.root, include=include, exclude=exclude)
                  else:
                      matcher = None
                  cgstream = changegroup.makestream(repo, outgoing, version, source,
                                                    bundlecaps=bundlecaps, matcher=matcher)
                  part = bundler.newpart('changegroup', data=cgstream)
                  if cgversions:
                      part.addparam('version', version)
                  part.addparam('nbchanges', '%d' % len(outgoing.missing),
                                mandatory=False)
                  if 'treemanifest' in repo.requirements:
                      part.addparam('treemanifest', '1')
                  if (kwargs.get(r'narrow', False) and kwargs.get(r'narrow_acl', False)
                      and (include or exclude)):
-                     narrowspecpart = bundler.newpart('narrow:spec')
-                     if include:
-                         narrowspecpart.addparam(
-                             'include', '\n'.join(include), mandatory=True)
-                     if exclude:
-                         narrowspecpart.addparam(
-                             'exclude', '\n'.join(exclude), mandatory=True)
+                     # this is mandatory because otherwise ACL clients won't work
+                     narrowspecpart = bundler.newpart('Narrow:responsespec')
+                     narrowspecpart.data = '%s\0%s' % ('\n'.join(include),
+                                                        '\n'.join(exclude))
              @getbundle2partsgenerator('bookmarks')
              def _getbundlebookmarkpart(bundler, repo, source, bundlecaps=None,
                                            b2caps=None, **kwargs):
                  """add a bookmark part to the requested bundle"""
                  if not kwargs.get(r'bookmarks', False):
                      return
                  if 'bookmarks' not in b2caps:
                      raise error.Abort(_('no common bookmarks exchange method'))
                  books  = bookmod.listbinbookmarks(repo)
                  data = bookmod.binaryencode(books)
                  if data:
                      bundler.newpart('bookmarks', data=data)
              @getbundle2partsgenerator('listkeys')
              def _getbundlelistkeysparts(bundler, repo, source, bundlecaps=None,
                                          b2caps=None, **kwargs):
                  """add parts containing listkeys namespaces to the requested bundle"""
                  listkeys = kwargs.get(r'listkeys', ())
                  for namespace in listkeys:
                      part = bundler.newpart('listkeys')
                      part.addparam('namespace', namespace)
                      keys = repo.listkeys(namespace).items()
                      part.data = pushkey.encodekeys(keys)
              @getbundle2partsgenerator('obsmarkers')
              def _getbundleobsmarkerpart(bundler, repo, source, bundlecaps=None,
                                          b2caps=None, heads=None, **kwargs):
                  """add an obsolescence markers part to the requested bundle"""
                  if kwargs.get(r'obsmarkers', False):
                      if heads is None:
                          heads = repo.heads()
                      subset = [c.node() for c in repo.set('::%ln', heads)]
                      markers = repo.obsstore.relevantmarkers(subset)
                      markers = sorted(markers)
                      bundle2.buildobsmarkerspart(bundler, markers)
              @getbundle2partsgenerator('phases')
              def _getbundlephasespart(bundler, repo, source, bundlecaps=None,
                                          b2caps=None, heads=None, **kwargs):
                  """add phase heads part to the requested bundle"""
                  if kwargs.get(r'phases', False):
                      if not 'heads' in b2caps.get('phases'):
                          raise error.Abort(_('no common phases exchange method'))
                      if heads is None:
                          heads = repo.heads()
                      headsbyphase = collections.defaultdict(set)
                      if repo.publishing():
                          headsbyphase[phases.public] = heads
                      else:
                          # find the appropriate heads to move
                          phase = repo._phasecache.phase
                          node = repo.changelog.node
                          rev = repo.changelog.rev
                          for h in heads:
                              headsbyphase[phase(repo, rev(h))].add(h)
                          seenphases = list(headsbyphase.keys())
                          # We do not handle anything but public and draft phase for now)
                          if seenphases:
                              assert max(seenphases) <= phases.draft
                          # if client is pulling non-public changesets, we need to find
                          # intermediate public heads.
                          draftheads = headsbyphase.get(phases.draft, set())
                          if draftheads:
                              publicheads = headsbyphase.get(phases.public, set())
                              revset = 'heads(only(%ln, %ln) and public())'
                              extraheads = repo.revs(revset, draftheads, publicheads)
                              for r in extraheads:
                                  headsbyphase[phases.public].add(node(r))
                      # transform data in a format used by the encoding function
                      phasemapping = []
                      for phase in phases.allphases:
                          phasemapping.append(sorted(headsbyphase[phase]))
                      # generate the actual part
                      phasedata = phases.binaryencode(phasemapping)
                      bundler.newpart('phase-heads', data=phasedata)
              @getbundle2partsgenerator('hgtagsfnodes')
              def _getbundletagsfnodes(bundler, repo, source, bundlecaps=None,
                                       b2caps=None, heads=None, common=None,
                                       **kwargs):
                  """Transfer the .hgtags filenodes mapping.
                  Only values for heads in this bundle will be transferred.
                  The part data consists of pairs of 20 byte changeset node and .hgtags
                  filenodes raw values.
                  """
                  # Don't send unless:
                  # - changeset are being exchanged,
                  # - the client supports it.
                  if not (kwargs.get(r'cg', True) and 'hgtagsfnodes' in b2caps):
                      return
                  outgoing = _computeoutgoing(repo, heads, common)
                  bundle2.addparttagsfnodescache(repo, bundler, outgoing)
              @getbundle2partsgenerator('cache:rev-branch-cache')
              def _getbundlerevbranchcache(bundler, repo, source, bundlecaps=None,
                                           b2caps=None, heads=None, common=None,
                                           **kwargs):
                  """Transfer the rev-branch-cache mapping
                  The payload is a series of data related to each branch
 ) branch name length
 ) number of open heads
 ) number of closed heads
 ) open heads nodes
 ) closed heads nodes
                  """
                  # Don't send unless:
                  # - changeset are being exchanged,
                  # - the client supports it.
                  # - narrow bundle isn't in play (not currently compatible).
                  if (not kwargs.get(r'cg', True)
                      or 'rev-branch-cache' not in b2caps
                      or kwargs.get(r'narrow', False)
                      or repo.ui.has_section(_NARROWACL_SECTION)):
                      return
                  outgoing = _computeoutgoing(repo, heads, common)
                  bundle2.addpartrevbranchcache(repo, bundler, outgoing)
              def check_heads(repo, their_heads, context):
                  """check if the heads of a repo have been modified
                  Used by peer for unbundling.
                  """
                  heads = repo.heads()
                  heads_hash = hashlib.sha1(''.join(sorted(heads))).digest()
                  if not (their_heads == ['force'] or their_heads == heads or
                          their_heads == ['hashed', heads_hash]):
                      # someone else committed/pushed/unbundled while we
                      # were transferring data
                      raise error.PushRaced('repository changed while %s - '
                                            'please try again' % context)
              def unbundle(repo, cg, heads, source, url):
                  """Apply a bundle to a repo.
                  this function makes sure the repo is locked during the application and have
                  mechanism to check that no push race occurred between the creation of the
                  bundle and its application.
                  If the push was raced as PushRaced exception is raised."""
                  r = 0
                  # need a transaction when processing a bundle2 stream
                  # [wlock, lock, tr] - needs to be an array so nested functions can modify it
                  lockandtr = [None, None, None]
                  recordout = None
                  # quick fix for output mismatch with bundle2 in 3.4
                  captureoutput = repo.ui.configbool('experimental', 'bundle2-output-capture')
                  if url.startswith('remote:http:') or url.startswith('remote:https:'):
                      captureoutput = True
                  try:
                      # note: outside bundle1, 'heads' is expected to be empty and this
                      # 'check_heads' call wil be a no-op
                      check_heads(repo, heads, 'uploading changes')
                      # push can proceed
                      if not isinstance(cg, bundle2.unbundle20):
                          # legacy case: bundle1 (changegroup 01)
                          txnname = "\n".join([source, util.hidepassword(url)])
                          with repo.lock(), repo.transaction(txnname) as tr:
                              op = bundle2.applybundle(repo, cg, tr, source, url)
                              r = bundle2.combinechangegroupresults(op)
                      else:
                          r = None
                          try:
                              def gettransaction():
                                  if not lockandtr[2]:
                                      lockandtr[0] = repo.wlock()
                                      lockandtr[1] = repo.lock()
                                      lockandtr[2] = repo.transaction(source)
                                      lockandtr[2].hookargs['source'] = source
                                      lockandtr[2].hookargs['url'] = url
                                      lockandtr[2].hookargs['bundle2'] = '1'
                                  return lockandtr[2]
                              # Do greedy locking by default until we're satisfied with lazy
                              # locking.
                              if not repo.ui.configbool('experimental', 'bundle2lazylocking'):
                                  gettransaction()
                              op = bundle2.bundleoperation(repo, gettransaction,
                                                           captureoutput=captureoutput,
                                                           source='push')
                              try:
                                  op = bundle2.processbundle(repo, cg, op=op)
                              finally:
                                  r = op.reply
                                  if captureoutput and r is not None:
                                      repo.ui.pushbuffer(error=True, subproc=True)
                                      def recordout(output):
                                          r.newpart('output', data=output, mandatory=False)
                              if lockandtr[2] is not None:
                                  lockandtr[2].close()
                          except BaseException as exc:
                              exc.duringunbundle2 = True
                              if captureoutput and r is not None:
                                  parts = exc._bundle2salvagedoutput = r.salvageoutput()
                                  def recordout(output):
                                      part = bundle2.bundlepart('output', data=output,
                                                                mandatory=False)
                                      parts.append(part)
                              raise
                  finally:
                      lockmod.release(lockandtr[2], lockandtr[1], lockandtr[0])
                      if recordout is not None:
                          recordout(repo.ui.popbuffer())
                  return r
              def _maybeapplyclonebundle(pullop):
                  """Apply a clone bundle from a remote, if possible."""
                  repo = pullop.repo
                  remote = pullop.remote
                  if not repo.ui.configbool('ui', 'clonebundles'):
                      return
                  # Only run if local repo is empty.
                  if len(repo):
                      return
                  if pullop.heads:
                      return
                  if not remote.capable('clonebundles'):
                      return
                  with remote.commandexecutor() as e:
                      res = e.callcommand('clonebundles', {}).result()
                  # If we call the wire protocol command, that's good enough to record the
                  # attempt.
                  pullop.clonebundleattempted = True
                  entries = parseclonebundlesmanifest(repo, res)
                  if not entries:
                      repo.ui.note(_('no clone bundles available on remote; '
                                     'falling back to regular clone\n'))
                      return
                  entries = filterclonebundleentries(
                      repo, entries, streamclonerequested=pullop.streamclonerequested)
                  if not entries:
                      # There is a thundering herd concern here. However, if a server
                      # operator doesn't advertise bundles appropriate for its clients,
                      # they deserve what's coming. Furthermore, from a client's
                      # perspective, no automatic fallback would mean not being able to
                      # clone!
                      repo.ui.warn(_('no compatible clone bundles available on server; '
                                     'falling back to regular clone\n'))
                      repo.ui.warn(_('(you may want to report this to the server '
                                     'operator)\n'))
                      return
                  entries = sortclonebundleentries(repo.ui, entries)
                  url = entries[0]['URL']
                  repo.ui.status(_('applying clone bundle from %s\n') % url)
                  if trypullbundlefromurl(repo.ui, repo, url):
                      repo.ui.status(_('finished applying clone bundle\n'))
                  # Bundle failed.
                  #
                  # We abort by default to avoid the thundering herd of
                  # clients flooding a server that was expecting expensive
                  # clone load to be offloaded.
                  elif repo.ui.configbool('ui', 'clonebundlefallback'):
                      repo.ui.warn(_('falling back to normal clone\n'))
                  else:
                      raise error.Abort(_('error applying bundle'),
                                        hint=_('if this error persists, consider contacting '
                                               'the server operator or disable clone '
                                               'bundles via '
                                               '"--config ui.clonebundles=false"'))
              def parseclonebundlesmanifest(repo, s):
                  """Parses the raw text of a clone bundles manifest.
                  Returns a list of dicts. The dicts have a ``URL`` key corresponding
                  to the URL and other keys are the attributes for the entry.
                  """
                  m = []
                  for line in s.splitlines():
                      fields = line.split()
                      if not fields:
                          continue
                      attrs = {'URL': fields[0]}
                      for rawattr in fields[1:]:
                          key, value = rawattr.split('=', 1)
                          key = urlreq.unquote(key)
                          value = urlreq.unquote(value)
                          attrs[key] = value
                          # Parse BUNDLESPEC into components. This makes client-side
                          # preferences easier to specify since you can prefer a single
                          # component of the BUNDLESPEC.
                          if key == 'BUNDLESPEC':
                              try:
                                  bundlespec = parsebundlespec(repo, value)
                                  attrs['COMPRESSION'] = bundlespec.compression
                                  attrs['VERSION'] = bundlespec.version
                              except error.InvalidBundleSpecification:
                                  pass
                              except error.UnsupportedBundleSpecification:
                                  pass
                      m.append(attrs)
                  return m
              def isstreamclonespec(bundlespec):
                  # Stream clone v1
                  if (bundlespec.wirecompression == 'UN' and bundlespec.wireversion == 's1'):
                      return True
                  # Stream clone v2
                  if (bundlespec.wirecompression == 'UN' and
                      bundlespec.wireversion == '02' and
                      bundlespec.contentopts.get('streamv2')):
                      return True
                  return False
              def filterclonebundleentries(repo, entries, streamclonerequested=False):
                  """Remove incompatible clone bundle manifest entries.
                  Accepts a list of entries parsed with ``parseclonebundlesmanifest``
                  and returns a new list consisting of only the entries that this client
                  should be able to apply.
                  There is no guarantee we'll be able to apply all returned entries because
                  the metadata we use to filter on may be missing or wrong.
                  """
                  newentries = []
                  for entry in entries:
                      spec = entry.get('BUNDLESPEC')
                      if spec:
                          try:
                              bundlespec = parsebundlespec(repo, spec, strict=True)
                              # If a stream clone was requested, filter out non-streamclone
                              # entries.
                              if streamclonerequested and not isstreamclonespec(bundlespec):
                                  repo.ui.debug('filtering %s because not a stream clone\n' %
                                                entry['URL'])
                                  continue
                          except error.InvalidBundleSpecification as e:
                              repo.ui.debug(stringutil.forcebytestr(e) + '\n')
                              continue
                          except error.UnsupportedBundleSpecification as e:
                              repo.ui.debug('filtering %s because unsupported bundle '
                                            'spec: %s\n' % (
                                                entry['URL'], stringutil.forcebytestr(e)))
                              continue
                      # If we don't have a spec and requested a stream clone, we don't know
                      # what the entry is so don't attempt to apply it.
                      elif streamclonerequested:
                          repo.ui.debug('filtering %s because cannot determine if a stream '
                                        'clone bundle\n' % entry['URL'])
                          continue
                      if 'REQUIRESNI' in entry and not sslutil.hassni:
                          repo.ui.debug('filtering %s because SNI not supported\n' %
                                        entry['URL'])
                          continue
                      newentries.append(entry)
                  return newentries
              class clonebundleentry(object):
                  """Represents an item in a clone bundles manifest.
                  This rich class is needed to support sorting since sorted() in Python 3
                  doesn't support ``cmp`` and our comparison is complex enough that ``key=``
                  won't work.
                  """
                  def __init__(self, value, prefers):
                      self.value = value
                      self.prefers = prefers
                  def _cmp(self, other):
                      for prefkey, prefvalue in self.prefers:
                          avalue = self.value.get(prefkey)
                          bvalue = other.value.get(prefkey)
                          # Special case for b missing attribute and a matches exactly.
                          if avalue is not None and bvalue is None and avalue == prefvalue:
                              return -1
                          # Special case for a missing attribute and b matches exactly.
                          if bvalue is not None and avalue is None and bvalue == prefvalue:
                              return 1
                          # We can't compare unless attribute present on both.
                          if avalue is None or bvalue is None:
                              continue
                          # Same values should fall back to next attribute.
                          if avalue == bvalue:
                              continue
                          # Exact matches come first.
                          if avalue == prefvalue:
                              return -1
                          if bvalue == prefvalue:
                              return 1
                          # Fall back to next attribute.
                          continue
                      # If we got here we couldn't sort by attributes and prefers. Fall
                      # back to index order.
                      return 0
                  def __lt__(self, other):
                      return self._cmp(other) < 0
                  def __gt__(self, other):
                      return self._cmp(other) > 0
                  def __eq__(self, other):
                      return self._cmp(other) == 0
                  def __le__(self, other):
                      return self._cmp(other) <= 0
                  def __ge__(self, other):
                      return self._cmp(other) >= 0
                  def __ne__(self, other):
                      return self._cmp(other) != 0
              def sortclonebundleentries(ui, entries):
                  prefers = ui.configlist('ui', 'clonebundleprefers')
                  if not prefers:
                      return list(entries)
                  prefers = [p.split('=', 1) for p in prefers]
                  items = sorted(clonebundleentry(v, prefers) for v in entries)
                  return [i.value for i in items]
              def trypullbundlefromurl(ui, repo, url):
                  """Attempt to apply a bundle from a URL."""
                  with repo.lock(), repo.transaction('bundleurl') as tr:
                      try:
                          fh = urlmod.open(ui, url)
                          cg = readbundle(ui, fh, 'stream')
                          if isinstance(cg, streamclone.streamcloneapplier):
                              cg.apply(repo)
                          else:
                              bundle2.applybundle(repo, cg, tr, 'clonebundles', url)
                          return True
                      except urlerr.httperror as e:
                          ui.warn(_('HTTP error fetching bundle: %s\n') %
                                  stringutil.forcebytestr(e))
                      except urlerr.urlerror as e:
                          ui.warn(_('error fetching bundle: %s\n') %
                                  stringutil.forcebytestr(e.reason))
                      return False

tests/hghave.py

0 +1 -1

              from __future__ import absolute_import
              import os
              import re
              import socket
              import stat
              import subprocess
              import sys
              import tempfile
              tempprefix = 'hg-hghave-'
              checks = {
                  "true": (lambda: True, "yak shaving"),
                  "false": (lambda: False, "nail clipper"),
              }
              try:
                  import msvcrt
                  msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
                  msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
              except ImportError:
                  pass
              stdout = getattr(sys.stdout, 'buffer', sys.stdout)
              stderr = getattr(sys.stderr, 'buffer', sys.stderr)
              if sys.version_info[0] >= 3:
                  def _bytespath(p):
                      if p is None:
                          return p
                      return p.encode('utf-8')
                  def _strpath(p):
                      if p is None:
                          return p
                      return p.decode('utf-8')
              else:
                  def _bytespath(p):
                      return p
                  _strpath = _bytespath
              def check(name, desc):
                  """Registers a check function for a feature."""
                  def decorator(func):
                      checks[name] = (func, desc)
                      return func
                  return decorator
              def checkvers(name, desc, vers):
                  """Registers a check function for each of a series of versions.
                  vers can be a list or an iterator"""
                  def decorator(func):
                      def funcv(v):
                          def f():
                              return func(v)
                          return f
                      for v in vers:
                          v = str(v)
                          f = funcv(v)
                          checks['%s%s' % (name, v.replace('.', ''))] = (f, desc % v)
                      return func
                  return decorator
              def checkfeatures(features):
                  result = {
                      'error': [],
                      'missing': [],
                      'skipped': [],
                  }
                  for feature in features:
                      negate = feature.startswith('no-')
                      if negate:
                          feature = feature[3:]
                      if feature not in checks:
                          result['missing'].append(feature)
                          continue
                      check, desc = checks[feature]
                      try:
                          available = check()
                      except Exception:
                          result['error'].append('hghave check failed: %s' % feature)
                          continue
                      if not negate and not available:
                          result['skipped'].append('missing feature: %s' % desc)
                      elif negate and available:
                          result['skipped'].append('system supports %s' % desc)
                  return result
              def require(features):
                  """Require that features are available, exiting if not."""
                  result = checkfeatures(features)
                  for missing in result['missing']:
                      stderr.write(('skipped: unknown feature: %s\n'
                                    % missing).encode('utf-8'))
                  for msg in result['skipped']:
                      stderr.write(('skipped: %s\n' % msg).encode('utf-8'))
                  for msg in result['error']:
                      stderr.write(('%s\n' % msg).encode('utf-8'))
                  if result['missing']:
                      sys.exit(2)
                  if result['skipped'] or result['error']:
                      sys.exit(1)
              def matchoutput(cmd, regexp, ignorestatus=False):
                  """Return the match object if cmd executes successfully and its output
                  is matched by the supplied regular expression.
                  """
                  r = re.compile(regexp)
                  p = subprocess.Popen(
                      cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
                  s = p.communicate()[0]
                  ret = p.returncode
                  return (ignorestatus or not ret) and r.search(s)
              @check("baz", "GNU Arch baz client")
              def has_baz():
                  return matchoutput('baz --version 2>&1', br'baz Bazaar version')
              @check("bzr", "Canonical's Bazaar client")
              def has_bzr():
                  try:
                      import bzrlib
                      import bzrlib.bzrdir
                      import bzrlib.errors
                      import bzrlib.revision
                      import bzrlib.revisionspec
                      bzrlib.revisionspec.RevisionSpec
                      return bzrlib.__doc__ is not None
                  except (AttributeError, ImportError):
                      return False
              @checkvers("bzr", "Canonical's Bazaar client >= %s", (1.14,))
              def has_bzr_range(v):
-                 major, minor = v.split('.')[0:2]
+                 major, minor = v.split('rc')[0].split('.')[0:2]
                  try:
                      import bzrlib
                      return (bzrlib.__doc__ is not None
                              and bzrlib.version_info[:2] >= (int(major), int(minor)))
                  except ImportError:
                      return False
              @check("chg", "running with chg")
              def has_chg():
                  return 'CHGHG' in os.environ
              @check("cvs", "cvs client/server")
              def has_cvs():
                  re = br'Concurrent Versions System.*?server'
                  return matchoutput('cvs --version 2>&1', re) and not has_msys()
              @check("cvs112", "cvs client/server 1.12.* (not cvsnt)")
              def has_cvs112():
                  re = br'Concurrent Versions System \(CVS\) 1.12.*?server'
                  return matchoutput('cvs --version 2>&1', re) and not has_msys()
              @check("cvsnt", "cvsnt client/server")
              def has_cvsnt():
                  re = br'Concurrent Versions System \(CVSNT\) (\d+).(\d+).*\(client/server\)'
                  return matchoutput('cvsnt --version 2>&1', re)
              @check("darcs", "darcs client")
              def has_darcs():
                  return matchoutput('darcs --version', br'\b2\.([2-9]|\d{2})', True)
              @check("mtn", "monotone client (>= 1.0)")
              def has_mtn():
                  return matchoutput('mtn --version', br'monotone', True) and not matchoutput(
                      'mtn --version', br'monotone 0\.', True)
              @check("eol-in-paths", "end-of-lines in paths")
              def has_eol_in_paths():
                  try:
                      fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix, suffix='\n\r')
                      os.close(fd)
                      os.remove(path)
                      return True
                  except (IOError, OSError):
                      return False
              @check("execbit", "executable bit")
              def has_executablebit():
                  try:
                      EXECFLAGS = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
                      fh, fn = tempfile.mkstemp(dir='.', prefix=tempprefix)
                      try:
                          os.close(fh)
                          m = os.stat(fn).st_mode & 0o777
                          new_file_has_exec = m & EXECFLAGS
                          os.chmod(fn, m ^ EXECFLAGS)
                          exec_flags_cannot_flip = ((os.stat(fn).st_mode & 0o777) == m)
                      finally:
                          os.unlink(fn)
                  except (IOError, OSError):
                      # we don't care, the user probably won't be able to commit anyway
                      return False
                  return not (new_file_has_exec or exec_flags_cannot_flip)
              @check("icasefs", "case insensitive file system")
              def has_icasefs():
                  # Stolen from mercurial.util
                  fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)
                  os.close(fd)
                  try:
                      s1 = os.stat(path)
                      d, b = os.path.split(path)
                      p2 = os.path.join(d, b.upper())
                      if path == p2:
                          p2 = os.path.join(d, b.lower())
                      try:
                          s2 = os.stat(p2)
                          return s2 == s1
                      except OSError:
                          return False
                  finally:
                      os.remove(path)
              @check("fifo", "named pipes")
              def has_fifo():
                  if getattr(os, "mkfifo", None) is None:
                      return False
                  name = tempfile.mktemp(dir='.', prefix=tempprefix)
                  try:
                      os.mkfifo(name)
                      os.unlink(name)
                      return True
                  except OSError:
                      return False
              @check("killdaemons", 'killdaemons.py support')
              def has_killdaemons():
                  return True
              @check("cacheable", "cacheable filesystem")
              def has_cacheable_fs():
                  from mercurial import util
                  fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)
                  os.close(fd)
                  try:
                      return util.cachestat(path).cacheable()
                  finally:
                      os.remove(path)
              @check("lsprof", "python lsprof module")
              def has_lsprof():
                  try:
                      import _lsprof
                      _lsprof.Profiler # silence unused import warning
                      return True
                  except ImportError:
                      return False
              def gethgversion():
                  m = matchoutput('hg --version --quiet 2>&1', br'(\d+)\.(\d+)')
                  if not m:
                      return (0, 0)
                  return (int(m.group(1)), int(m.group(2)))
              @checkvers("hg", "Mercurial >= %s",
                          list([(1.0 * x) / 10 for x in range(9, 99)]))
              def has_hg_range(v):
                  major, minor = v.split('.')[0:2]
                  return gethgversion() >= (int(major), int(minor))
              @check("hg08", "Mercurial >= 0.8")
              def has_hg08():
                  if checks["hg09"][0]():
                      return True
                  return matchoutput('hg help annotate 2>&1', '--date')
              @check("hg07", "Mercurial >= 0.7")
              def has_hg07():
                  if checks["hg08"][0]():
                      return True
                  return matchoutput('hg --version --quiet 2>&1', 'Mercurial Distributed SCM')
              @check("hg06", "Mercurial >= 0.6")
              def has_hg06():
                  if checks["hg07"][0]():
                      return True
                  return matchoutput('hg --version --quiet 2>&1', 'Mercurial version')
              @check("gettext", "GNU Gettext (msgfmt)")
              def has_gettext():
                  return matchoutput('msgfmt --version', br'GNU gettext-tools')
              @check("git", "git command line client")
              def has_git():
                  return matchoutput('git --version 2>&1', br'^git version')
              def getgitversion():
                  m = matchoutput('git --version 2>&1', br'git version (\d+)\.(\d+)')
                  if not m:
                      return (0, 0)
                  return (int(m.group(1)), int(m.group(2)))
              # https://github.com/git-lfs/lfs-test-server
              @check("lfs-test-server", "git-lfs test server")
              def has_lfsserver():
                  exe = 'lfs-test-server'
                  if has_windows():
                      exe = 'lfs-test-server.exe'
                  return any(
                      os.access(os.path.join(path, exe), os.X_OK)
                      for path in os.environ["PATH"].split(os.pathsep)
                  )
              @checkvers("git", "git client (with ext::sh support) version >= %s", (1.9,))
              def has_git_range(v):
                  major, minor = v.split('.')[0:2]
                  return getgitversion() >= (int(major), int(minor))
              @check("docutils", "Docutils text processing library")
              def has_docutils():
                  try:
                      import docutils.core
                      docutils.core.publish_cmdline # silence unused import
                      return True
                  except ImportError:
                      return False
              def getsvnversion():
                  m = matchoutput('svn --version --quiet 2>&1', br'^(\d+)\.(\d+)')
                  if not m:
                      return (0, 0)
                  return (int(m.group(1)), int(m.group(2)))
              @checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5))
              def has_svn_range(v):
                  major, minor = v.split('.')[0:2]
                  return getsvnversion() >= (int(major), int(minor))
              @check("svn", "subversion client and admin tools")
              def has_svn():
                  return (matchoutput('svn --version 2>&1', br'^svn, version') and
                          matchoutput('svnadmin --version 2>&1', br'^svnadmin, version'))
              @check("svn-bindings", "subversion python bindings")
              def has_svn_bindings():
                  try:
                      import svn.core
                      version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR
                      if version < (1, 4):
                          return False
                      return True
                  except ImportError:
                      return False
              @check("p4", "Perforce server and client")
              def has_p4():
                  return (matchoutput('p4 -V', br'Rev\. P4/') and
                          matchoutput('p4d -V', br'Rev\. P4D/'))
              @check("symlink", "symbolic links")
              def has_symlink():
                  if getattr(os, "symlink", None) is None:
                      return False
                  name = tempfile.mktemp(dir='.', prefix=tempprefix)
                  try:
                      os.symlink(".", name)
                      os.unlink(name)
                      return True
                  except (OSError, AttributeError):
                      return False
              @check("hardlink", "hardlinks")
              def has_hardlink():
                  from mercurial import util
                  fh, fn = tempfile.mkstemp(dir='.', prefix=tempprefix)
                  os.close(fh)
                  name = tempfile.mktemp(dir='.', prefix=tempprefix)
                  try:
                      util.oslink(_bytespath(fn), _bytespath(name))
                      os.unlink(name)
                      return True
                  except OSError:
                      return False
                  finally:
                      os.unlink(fn)
              @check("hardlink-whitelisted", "hardlinks on whitelisted filesystems")
              def has_hardlink_whitelisted():
                  from mercurial import util
                  try:
                      fstype = util.getfstype(b'.')
                  except OSError:
                      return False
                  return fstype in util._hardlinkfswhitelist
              @check("rmcwd", "can remove current working directory")
              def has_rmcwd():
                  ocwd = os.getcwd()
                  temp = tempfile.mkdtemp(dir='.', prefix=tempprefix)
                  try:
                      os.chdir(temp)
                      # On Linux, 'rmdir .' isn't allowed, but the other names are okay.
                      # On Solaris and Windows, the cwd can't be removed by any names.
                      os.rmdir(os.getcwd())
                      return True
                  except OSError:
                      return False
                  finally:
                      os.chdir(ocwd)
                      # clean up temp dir on platforms where cwd can't be removed
                      try:
                          os.rmdir(temp)
                      except OSError:
                          pass
              @check("tla", "GNU Arch tla client")
              def has_tla():
                  return matchoutput('tla --version 2>&1', br'The GNU Arch Revision')
              @check("gpg", "gpg client")
              def has_gpg():
                  return matchoutput('gpg --version 2>&1', br'GnuPG')
              @check("gpg2", "gpg client v2")
              def has_gpg2():
                  return matchoutput('gpg --version 2>&1', br'GnuPG[^0-9]+2\.')
              @check("gpg21", "gpg client v2.1+")
              def has_gpg21():
                  return matchoutput('gpg --version 2>&1', br'GnuPG[^0-9]+2\.(?!0)')
              @check("unix-permissions", "unix-style permissions")
              def has_unix_permissions():
                  d = tempfile.mkdtemp(dir='.', prefix=tempprefix)
                  try:
                      fname = os.path.join(d, 'foo')
                      for umask in (0o77, 0o07, 0o22):
                          os.umask(umask)
                          f = open(fname, 'w')
                          f.close()
                          mode = os.stat(fname).st_mode
                          os.unlink(fname)
                          if mode & 0o777 != ~umask & 0o666:
                              return False
                      return True
                  finally:
                      os.rmdir(d)
              @check("unix-socket", "AF_UNIX socket family")
              def has_unix_socket():
                  return getattr(socket, 'AF_UNIX', None) is not None
              @check("root", "root permissions")
              def has_root():
                  return getattr(os, 'geteuid', None) and os.geteuid() == 0
              @check("pyflakes", "Pyflakes python linter")
              def has_pyflakes():
                  return matchoutput("sh -c \"echo 'import re' 2>&1 | pyflakes\"",
                                     br"<stdin>:1: 're' imported but unused",
                                     True)
              @check("pylint", "Pylint python linter")
              def has_pylint():
                  return matchoutput("pylint --help",
                                     br"Usage:  pylint",
                                     True)
              @check("clang-format", "clang-format C code formatter")
              def has_clang_format():
                  m = matchoutput('clang-format --version', br'clang-format version (\d)')
                  # style changed somewhere between 4.x and 6.x
                  return m and int(m.group(1)) >= 6
              @check("jshint", "JSHint static code analysis tool")
              def has_jshint():
                  return matchoutput("jshint --version 2>&1", br"jshint v")
              @check("pygments", "Pygments source highlighting library")
              def has_pygments():
                  try:
                      import pygments
                      pygments.highlight # silence unused import warning
                      return True
                  except ImportError:
                      return False
              @check("outer-repo", "outer repo")
              def has_outer_repo():
                  # failing for other reasons than 'no repo' imply that there is a repo
                  return not matchoutput('hg root 2>&1',
                                         br'abort: no repository found', True)
              @check("ssl", "ssl module available")
              def has_ssl():
                  try:
                      import ssl
                      ssl.CERT_NONE
                      return True
                  except ImportError:
                      return False
              @check("sslcontext", "python >= 2.7.9 ssl")
              def has_sslcontext():
                  try:
                      import ssl
                      ssl.SSLContext
                      return True
                  except (ImportError, AttributeError):
                      return False
              @check("defaultcacerts", "can verify SSL certs by system's CA certs store")
              def has_defaultcacerts():
                  from mercurial import sslutil, ui as uimod
                  ui = uimod.ui.load()
                  return sslutil._defaultcacerts(ui) or sslutil._canloaddefaultcerts
              @check("defaultcacertsloaded", "detected presence of loaded system CA certs")
              def has_defaultcacertsloaded():
                  import ssl
                  from mercurial import sslutil, ui as uimod
                  if not has_defaultcacerts():
                      return False
                  if not has_sslcontext():
                      return False
                  ui = uimod.ui.load()
                  cafile = sslutil._defaultcacerts(ui)
                  ctx = ssl.create_default_context()
                  if cafile:
                      ctx.load_verify_locations(cafile=cafile)
                  else:
                      ctx.load_default_certs()
                  return len(ctx.get_ca_certs()) > 0
              @check("tls1.2", "TLS 1.2 protocol support")
              def has_tls1_2():
                  from mercurial import sslutil
                  return b'tls1.2' in sslutil.supportedprotocols
              @check("windows", "Windows")
              def has_windows():
                  return os.name == 'nt'
              @check("system-sh", "system() uses sh")
              def has_system_sh():
                  return os.name != 'nt'
              @check("serve", "platform and python can manage 'hg serve -d'")
              def has_serve():
                  return True
              @check("test-repo", "running tests from repository")
              def has_test_repo():
                  t = os.environ["TESTDIR"]
                  return os.path.isdir(os.path.join(t, "..", ".hg"))
              @check("tic", "terminfo compiler and curses module")
              def has_tic():
                  try:
                      import curses
                      curses.COLOR_BLUE
                      return matchoutput('test -x "`which tic`"', br'')
                  except ImportError:
                      return False
              @check("msys", "Windows with MSYS")
              def has_msys():
                  return os.getenv('MSYSTEM')
              @check("aix", "AIX")
              def has_aix():
                  return sys.platform.startswith("aix")
              @check("osx", "OS X")
              def has_osx():
                  return sys.platform == 'darwin'
              @check("osxpackaging", "OS X packaging tools")
              def has_osxpackaging():
                  try:
                      return (matchoutput('pkgbuild', br'Usage: pkgbuild ', ignorestatus=1)
                              and matchoutput(
                                  'productbuild', br'Usage: productbuild ',
                                  ignorestatus=1)
                              and matchoutput('lsbom', br'Usage: lsbom', ignorestatus=1)
                              and matchoutput(
                                  'xar --help', br'Usage: xar', ignorestatus=1))
                  except ImportError:
                      return False
              @check('linuxormacos', 'Linux or MacOS')
              def has_linuxormacos():
                  # This isn't a perfect test for MacOS. But it is sufficient for our needs.
                  return sys.platform.startswith(('linux', 'darwin'))
              @check("docker", "docker support")
              def has_docker():
                  pat = br'A self-sufficient runtime for'
                  if matchoutput('docker --help', pat):
                      if 'linux' not in sys.platform:
                          # TODO: in theory we should be able to test docker-based
                          # package creation on non-linux using boot2docker, but in
                          # practice that requires extra coordination to make sure
                          # $TESTTEMP is going to be visible at the same path to the
                          # boot2docker VM. If we figure out how to verify that, we
                          # can use the following instead of just saying False:
                          # return 'DOCKER_HOST' in os.environ
                          return False
                      return True
                  return False
              @check("debhelper", "debian packaging tools")
              def has_debhelper():
                  # Some versions of dpkg say `dpkg', some say 'dpkg' (` vs ' on the first
                  # quote), so just accept anything in that spot.
                  dpkg = matchoutput('dpkg --version',
                                     br"Debian .dpkg' package management program")
                  dh = matchoutput('dh --help',
                                   br'dh is a part of debhelper.', ignorestatus=True)
                  dh_py2 = matchoutput('dh_python2 --help',
                                       br'other supported Python versions')
                  # debuild comes from the 'devscripts' package, though you might want
                  # the 'build-debs' package instead, which has a dependency on devscripts.
                  debuild = matchoutput('debuild --help',
                                        br'to run debian/rules with given parameter')
                  return dpkg and dh and dh_py2 and debuild
              @check("debdeps",
                     "debian build dependencies (run dpkg-checkbuilddeps in contrib/)")
              def has_debdeps():
                  # just check exit status (ignoring output)
                  path = '%s/../contrib/packaging/debian/control' % os.environ['TESTDIR']
                  return matchoutput('dpkg-checkbuilddeps %s' % path, br'')
              @check("demandimport", "demandimport enabled")
              def has_demandimport():
                  # chg disables demandimport intentionally for performance wins.
                  return ((not has_chg()) and os.environ.get('HGDEMANDIMPORT') != 'disable')
              @checkvers("py", "Python >= %s", (2.7, 3.5, 3.6, 3.7, 3.8, 3.9))
              def has_python_range(v):
                  major, minor = v.split('.')[0:2]
                  py_major, py_minor = sys.version_info.major, sys.version_info.minor
                  return (py_major, py_minor) >= (int(major), int(minor))
              @check("py3", "running with Python 3.x")
              def has_py3():
                  return 3 == sys.version_info[0]
              @check("py3exe", "a Python 3.x interpreter is available")
              def has_python3exe():
                  return matchoutput('python3 -V', br'^Python 3.(5|6|7|8|9)')
              @check("pure", "running with pure Python code")
              def has_pure():
                  return any([
                      os.environ.get("HGMODULEPOLICY") == "py",
                      os.environ.get("HGTEST_RUN_TESTS_PURE") == "--pure",
                  ])
              @check("slow", "allow slow tests (use --allow-slow-tests)")
              def has_slow():
                  return os.environ.get('HGTEST_SLOW') == 'slow'
              @check("hypothesis", "Hypothesis automated test generation")
              def has_hypothesis():
                  try:
                      import hypothesis
                      hypothesis.given
                      return True
                  except ImportError:
                      return False
              @check("unziplinks", "unzip(1) understands and extracts symlinks")
              def unzip_understands_symlinks():
                  return matchoutput('unzip --help', br'Info-ZIP')
              @check("zstd", "zstd Python module available")
              def has_zstd():
                  try:
                      import mercurial.zstd
                      mercurial.zstd.__version__
                      return True
                  except ImportError:
                      return False
              @check("devfull", "/dev/full special file")
              def has_dev_full():
                  return os.path.exists('/dev/full')
              @check("virtualenv", "Python virtualenv support")
              def has_virtualenv():
                  try:
                      import virtualenv
                      virtualenv.ACTIVATE_SH
                      return True
                  except ImportError:
                      return False
              @check("fsmonitor", "running tests with fsmonitor")
              def has_fsmonitor():
                  return 'HGFSMONITOR_TESTS' in os.environ
              @check("fuzzywuzzy", "Fuzzy string matching library")
              def has_fuzzywuzzy():
                  try:
                      import fuzzywuzzy
                      fuzzywuzzy.__version__
                      return True
                  except ImportError:
                      return False
              @check("clang-libfuzzer", "clang new enough to include libfuzzer")
              def has_clang_libfuzzer():
                  mat = matchoutput('clang --version', br'clang version (\d)')
                  if mat:
                      # libfuzzer is new in clang 6
                      return int(mat.group(1)) > 5
                  return False
              @check("clang-6.0", "clang 6.0 with version suffix (libfuzzer included)")
              def has_clang60():
                  return matchoutput('clang-6.0 --version', br'clang version 6\.')
              @check("xdiff", "xdiff algorithm")
              def has_xdiff():
                  try:
                      from mercurial import policy
                      bdiff = policy.importmod('bdiff')
                      return bdiff.xdiffblocks(b'', b'') == [(0, 0, 0, 0)]
                  except (ImportError, AttributeError):
                      return False
              @check('extraextensions', 'whether tests are running with extra extensions')
              def has_extraextensions():
                  return 'HGTESTEXTRAEXTENSIONS' in os.environ
              def getrepofeatures():
                  """Obtain set of repository features in use.
                  HGREPOFEATURES can be used to define or remove features. It contains
                  a space-delimited list of feature strings. Strings beginning with ``-``
                  mean to remove.
                  """
                  # Default list provided by core.
                  features = {
                      'bundlerepo',
                      'revlogstore',
                      'fncache',
                  }
                  # Features that imply other features.
                  implies = {
                      'simplestore': ['-revlogstore', '-bundlerepo', '-fncache'],
                  }
                  for override in os.environ.get('HGREPOFEATURES', '').split(' '):
                      if not override:
                          continue
                      if override.startswith('-'):
                          if override[1:] in features:
                              features.remove(override[1:])
                      else:
                          features.add(override)
                          for imply in implies.get(override, []):
                              if imply.startswith('-'):
                                  if imply[1:] in features:
                                      features.remove(imply[1:])
                              else:
                                  features.add(imply)
                  return features
              @check('reporevlogstore', 'repository using the default revlog store')
              def has_reporevlogstore():
                  return 'revlogstore' in getrepofeatures()
              @check('reposimplestore', 'repository using simple storage extension')
              def has_reposimplestore():
                  return 'simplestore' in getrepofeatures()
              @check('repobundlerepo', 'whether we can open bundle files as repos')
              def has_repobundlerepo():
                  return 'bundlerepo' in getrepofeatures()
              @check('repofncache', 'repository has an fncache')
              def has_repofncache():
                  return 'fncache' in getrepofeatures()
              @check('sqlite', 'sqlite3 module is available')
              def has_sqlite():
                  try:
                      import sqlite3
                      version = sqlite3.sqlite_version_info
                  except ImportError:
                      return False
                  if version < (3, 8, 3):
                      # WITH clause not supported
                      return False
                  return matchoutput('sqlite3 -version', br'^3\.\d+')
              @check('vcr', 'vcr http mocking library')
              def has_vcr():
                  try:
                      import vcr
                      vcr.VCR
                      return True
                  except (ImportError, AttributeError):
                      pass
                  return False
              @check('emacs', 'GNU Emacs')
              def has_emacs():
                  # Our emacs lisp uses `with-eval-after-load` which is new in emacs
                  # 24.4, so we allow emacs 24.4, 24.5, and 25+ (24.5 was the last
                  # 24 release)
                  return matchoutput('emacs --version', b'GNU Emacs 2(4.4|4.5|5|6|7|8|9)')

tests/test-narrow-acl.t

0 +1 -1

              Make a narrow clone then archive it
                $ . "$TESTDIR/narrow-library.sh"
                $ hg init master
                $ cd master
                $ for x in `$TESTDIR/seq.py 3`; do
                >   echo $x > "f$x"
                >   hg add "f$x"
                >   hg commit -m "Add $x"
                > done
                $ cat >> .hg/hgrc << EOF
-               > [narrowhgacl]
+               > [narrowacl]
                > default.includes=f1 f2
                > EOF
                $ hg serve -a localhost -p $HGPORT1 -d --pid-file=hg.pid
                $ cat hg.pid >> "$DAEMON_PIDS"
                $ cd ..
                $ hg clone http://localhost:$HGPORT1 narrowclone1
                requesting all changes
                adding changesets
                adding manifests
                adding file changes
                added 3 changesets with 2 changes to 2 files
                new changesets * (glob)
                updating to branch default
 files updated, 0 files merged, 0 files removed, 0 files unresolved
              The clone directory should only contain f1 and f2
                $ ls -1 narrowclone1 | sort
                f1
                f2
              Requirements should contain narrowhg
                $ cat narrowclone1/.hg/requires | grep narrowhg
                narrowhg-experimental
              NarrowHG should track f1 and f2
                $ hg -R narrowclone1 tracked
                I path:f1
                I path:f2

tests/test-rebase-inmemory.t

0 +43 0

              #require symlink execbit
                $ cat << EOF >> $HGRCPATH
                > [phases]
                > publish=False
                > [extensions]
                > amend=
                > rebase=
                > debugdrawdag=$TESTDIR/drawdag.py
                > strip=
                > [rebase]
                > experimental.inmemory=1
                > [diff]
                > git=1
                > [alias]
                > tglog = log -G --template "{rev}: {node|short} '{desc}'\n"
                > EOF
              Rebase a simple DAG:
                $ hg init repo1
                $ cd repo1
                $ hg debugdrawdag <<'EOS'
                > c b
                > |/
                > d
                > |
                > a
                > EOS
                $ hg up -C a
 files updated, 0 files merged, 0 files removed, 0 files unresolved
                $ hg tglog
                o  3: 814f6bd05178 'c'
                |
                | o  2: db0e82a16a62 'b'
                |/
                o  1: 02952614a83d 'd'
                |
                @  0: b173517d0057 'a'
                $ hg cat -r 3 c
                c (no-eol)
                $ hg cat -r 2 b
                b (no-eol)
                $ hg rebase --debug -r b -d c | grep rebasing
                rebasing in-memory
                rebasing 2:db0e82a16a62 "b" (b)
                $ hg tglog
                o  3: ca58782ad1e4 'b'
                |
                o  2: 814f6bd05178 'c'
                |
                o  1: 02952614a83d 'd'
                |
                @  0: b173517d0057 'a'
                $ hg cat -r 3 b
                b (no-eol)
                $ hg cat -r 2 c
                c (no-eol)
                $ cd ..
              Case 2:
                $ hg init repo2
                $ cd repo2
                $ hg debugdrawdag <<'EOS'
                > c b
                > |/
                > d
                > |
                > a
                > EOS
              Add a symlink and executable file:
                $ hg up -C c
 files updated, 0 files merged, 0 files removed, 0 files unresolved
                $ ln -s somefile e
                $ echo f > f
                $ chmod +x f
                $ hg add e f
                $ hg amend -q
                $ hg up -Cq a
              Write files to the working copy, and ensure they're still there after the rebase
                $ echo "abc" > a
                $ ln -s def b
                $ echo "ghi" > c
                $ echo "jkl" > d
                $ echo "mno" > e
                $ hg tglog
                o  3: f56b71190a8f 'c'
                |
                | o  2: db0e82a16a62 'b'
                |/
                o  1: 02952614a83d 'd'
                |
                @  0: b173517d0057 'a'
                $ hg cat -r 3 c
                c (no-eol)
                $ hg cat -r 2 b
                b (no-eol)
                $ hg cat -r 3 e
                somefile (no-eol)
                $ hg rebase --debug -s b -d a | grep rebasing
                rebasing in-memory
                rebasing 2:db0e82a16a62 "b" (b)
                $ hg tglog
                o  3: fc055c3b4d33 'b'
                |
                | o  2: f56b71190a8f 'c'
                | |
                | o  1: 02952614a83d 'd'
                |/
                @  0: b173517d0057 'a'
                $ hg cat -r 2 c
                c (no-eol)
                $ hg cat -r 3 b
                b (no-eol)
                $ hg rebase --debug -s 1 -d 3 | grep rebasing
                rebasing in-memory
                rebasing 1:02952614a83d "d" (d)
                rebasing 2:f56b71190a8f "c"
                $ hg tglog
                o  3: 753feb6fd12a 'c'
                |
                o  2: 09c044d2cb43 'd'
                |
                o  1: fc055c3b4d33 'b'
                |
                @  0: b173517d0057 'a'
              Ensure working copy files are still there:
                $ cat a
                abc
                $ readlink.py b
                b -> def
                $ cat e
                mno
              Ensure symlink and executable files were rebased properly:
                $ hg up -Cq 3
                $ readlink.py e
                e -> somefile
                $ ls -l f | cut -c -10
                -rwxr-xr-x
              Rebase the working copy parent
                $ hg up -C 3
 files updated, 0 files merged, 0 files removed, 0 files unresolved
                $ hg rebase -r 3 -d 0 --debug | grep rebasing
                rebasing in-memory
                rebasing 3:753feb6fd12a "c" (tip)
                $ hg tglog
                @  3: 844a7de3e617 'c'
                |
                | o  2: 09c044d2cb43 'd'
                | |
                | o  1: fc055c3b4d33 'b'
                |/
                o  0: b173517d0057 'a'
              Test reporting of path conflicts
                $ hg rm a
                $ mkdir a
                $ touch a/a
                $ hg ci -Am "a/a"
                adding a/a
                $ hg tglog
                @  4: daf7dfc139cb 'a/a'
                |
                o  3: 844a7de3e617 'c'
                |
                | o  2: 09c044d2cb43 'd'
                | |
                | o  1: fc055c3b4d33 'b'
                |/
                o  0: b173517d0057 'a'
                $ hg rebase -r . -d 2
                rebasing 4:daf7dfc139cb "a/a" (tip)
                saved backup bundle to $TESTTMP/repo2/.hg/strip-backup/daf7dfc139cb-fdbfcf4f-rebase.hg
                $ hg tglog
                @  4: c6ad37a4f250 'a/a'
                |
                | o  3: 844a7de3e617 'c'
                | |
                o |  2: 09c044d2cb43 'd'
                | |
                o |  1: fc055c3b4d33 'b'
                |/
                o  0: b173517d0057 'a'
                $ echo foo > foo
                $ hg ci -Aqm "added foo"
                $ hg up '.^'
 files updated, 0 files merged, 1 files removed, 0 files unresolved
                $ echo bar > bar
                $ hg ci -Aqm "added bar"
                $ hg rm a/a
                $ echo a > a
                $ hg ci -Aqm "added a back!"
                $ hg tglog
                @  7: 855e9797387e 'added a back!'
                |
                o  6: d14530e5e3e6 'added bar'
                |
                | o  5: 9b94b9373deb 'added foo'
                |/
                o  4: c6ad37a4f250 'a/a'
                |
                | o  3: 844a7de3e617 'c'
                | |
                o |  2: 09c044d2cb43 'd'
                | |
                o |  1: fc055c3b4d33 'b'
                |/
                o  0: b173517d0057 'a'
                $ hg rebase -r . -d 5
                rebasing 7:855e9797387e "added a back!" (tip)
                saved backup bundle to $TESTTMP/repo2/.hg/strip-backup/855e9797387e-81ee4c5d-rebase.hg
                $ hg tglog
                @  7: bb3f02be2688 'added a back!'
                |
                | o  6: d14530e5e3e6 'added bar'
                | |
                o |  5: 9b94b9373deb 'added foo'
                |/
                o  4: c6ad37a4f250 'a/a'
                |
                | o  3: 844a7de3e617 'c'
                | |
                o |  2: 09c044d2cb43 'd'
                | |
                o |  1: fc055c3b4d33 'b'
                |/
                o  0: b173517d0057 'a'
                $ mkdir -p c/subdir
                $ echo c > c/subdir/file.txt
                $ hg add c/subdir/file.txt
                $ hg ci -m 'c/subdir/file.txt'
                $ hg rebase -r . -d 3 -n
                starting dry-run rebase; repository will not be changed
                rebasing 8:e147e6e3c490 "c/subdir/file.txt" (tip)
                abort: error: 'c/subdir/file.txt' conflicts with file 'c' in 3.
                [255]
                $ hg rebase -r 3 -d . -n
                starting dry-run rebase; repository will not be changed
                rebasing 3:844a7de3e617 "c"
                abort: error: file 'c' cannot be written because  'c/' is a directory in e147e6e3c490 (containing 1 entries: c/subdir/file.txt)
                [255]
                $ cd ..
              Test path auditing (issue5818)
                $ mkdir lib_
                $ ln -s lib_ lib
                $ hg init repo
                $ cd repo
                $ mkdir -p ".$TESTTMP/lib"
                $ touch ".$TESTTMP/lib/a"
                $ hg add ".$TESTTMP/lib/a"
                $ hg ci -m 'a'
                $ touch ".$TESTTMP/lib/b"
                $ hg add ".$TESTTMP/lib/b"
                $ hg ci -m 'b'
                $ hg up -q '.^'
                $ touch ".$TESTTMP/lib/c"
                $ hg add ".$TESTTMP/lib/c"
                $ hg ci -m 'c'
                created new head
                $ hg rebase -s 1 -d .
                rebasing 1:* "b" (glob)
                saved backup bundle to $TESTTMP/repo/.hg/strip-backup/*-rebase.hg (glob)
                $ cd ..
              Test dry-run rebasing
                $ hg init repo3
                $ cd repo3
                $ echo a>a
                $ hg ci -Aqma
                $ echo b>b
                $ hg ci -Aqmb
                $ echo c>c
                $ hg ci -Aqmc
                $ echo d>d
                $ hg ci -Aqmd
                $ echo e>e
                $ hg ci -Aqme
                $ hg up 1 -q
                $ echo f>f
                $ hg ci -Amf
                adding f
                created new head
                $ echo g>g
                $ hg ci -Aqmg
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
              Make sure it throws error while passing --continue or --abort with --dry-run
                $ hg rebase -s 2 -d 6 -n --continue
                abort: cannot specify both --dry-run and --continue
                [255]
                $ hg rebase -s 2 -d 6 -n --abort
                abort: cannot specify both --dry-run and --abort
                [255]
              Check dryrun gives correct results when there is no conflict in rebasing
                $ hg rebase -s 2 -d 6 -n
                starting dry-run rebase; repository will not be changed
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase
                $ hg diff
                $ hg status
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
              Check dryrun working with --collapse when there is no conflict
                $ hg rebase -s 2 -d 6 -n --collapse
                starting dry-run rebase; repository will not be changed
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                dry-run rebase completed successfully; run without -n/--dry-run to perform this rebase
              Check dryrun gives correct results when there is conflict in rebasing
              Make a conflict:
                $ hg up 6 -q
                $ echo conflict>e
                $ hg ci -Aqm "conflict with e"
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  7:d2c195b28050 test
                |  conflict with e
                |
                o  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
                $ hg rebase -s 2 -d 7 -n
                starting dry-run rebase; repository will not be changed
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                merging e
                transaction abort!
                rollback completed
                hit a merge conflict
                [1]
                $ hg diff
                $ hg status
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  7:d2c195b28050 test
                |  conflict with e
                |
                o  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
              Check dryrun working with --collapse when there is conflicts
                $ hg rebase -s 2 -d 7 -n --collapse
                starting dry-run rebase; repository will not be changed
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                merging e
                hit a merge conflict
                [1]
              In-memory rebase that fails due to merge conflicts
                $ hg rebase -s 2 -d 7
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                merging e
                transaction abort!
                rollback completed
                hit merge conflicts; re-running rebase without in-memory merge
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                merging e
                warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
                unresolved conflicts (see hg resolve, then hg rebase --continue)
                [1]
                $ hg rebase --abort
                saved backup bundle to $TESTTMP/repo3/.hg/strip-backup/c1e524d4287c-f91f82e1-backup.hg
                rebase aborted
              Retrying without in-memory merge won't lose working copy changes
                $ cd ..
                $ hg clone repo3 repo3-dirty -q
                $ cd repo3-dirty
                $ echo dirty > a
                $ hg rebase -s 2 -d 7
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                merging e
                transaction abort!
                rollback completed
                hit merge conflicts; re-running rebase without in-memory merge
                abort: uncommitted changes
                [255]
                $ cat a
                dirty
              Retrying without in-memory merge won't lose merge state
                $ cd ..
                $ hg clone repo3 repo3-merge-state -q
                $ cd repo3-merge-state
                $ hg merge 4
                merging e
                warning: conflicts while merging e! (edit, then use 'hg resolve --mark')
 files updated, 0 files merged, 0 files removed, 1 files unresolved
                use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
                [1]
                $ hg resolve -l
                U e
                $ hg rebase -s 2 -d 7
                rebasing 2:177f92b77385 "c"
                abort: outstanding merge conflicts
                [255]
                $ hg resolve -l
                U e
              ==========================
              Test for --confirm option|
              ==========================
                $ cd ..
                $ hg clone repo3 repo4 -q
                $ cd repo4
                $ hg strip 7 -q
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
              Check it gives error when both --dryrun and --confirm is used:
                $ hg rebase -s 2 -d . --confirm --dry-run
                abort: cannot specify both --confirm and --dry-run
                [255]
                $ hg rebase -s 2 -d . --confirm --abort
                abort: cannot specify both --confirm and --abort
                [255]
                $ hg rebase -s 2 -d . --confirm --continue
                abort: cannot specify both --confirm and --continue
                [255]
              Test --confirm option when there are no conflicts:
                $ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF
                > n
                > EOF
                starting in-memory rebase
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                rebase completed successfully
                apply changes (yn)? n
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
                $ hg rebase -s 2 -d . --keep --config ui.interactive=True --confirm << EOF
                > y
                > EOF
                starting in-memory rebase
                rebasing 2:177f92b77385 "c"
                rebasing 3:055a42cdd887 "d"
                rebasing 4:e860deea161a "e"
                rebase completed successfully
                apply changes (yn)? y
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                o  9:9fd28f55f6dc test
                |  e
                |
                o  8:12cbf031f469 test
                |  d
                |
                o  7:c83b1da5b1ae test
                |  c
                |
                @  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
              Test --confirm option when there is a conflict
                $ hg up tip -q
                $ echo ee>e
                $ hg ci --amend -m "conflict with e" -q
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  9:906d72f66a59 test
                |  conflict with e
                |
                o  8:12cbf031f469 test
                |  d
                |
                o  7:c83b1da5b1ae test
                |  c
                |
                o  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
                $ hg rebase -s 4 -d . --keep --confirm
                starting in-memory rebase
                rebasing 4:e860deea161a "e"
                merging e
                hit a merge conflict
                [1]
                $ hg log -G --template "{rev}:{short(node)} {person(author)}\n{firstline(desc)} {topic}\n\n"
                @  9:906d72f66a59 test
                |  conflict with e
                |
                o  8:12cbf031f469 test
                |  d
                |
                o  7:c83b1da5b1ae test
                |  c
                |
                o  6:baf10c5166d4 test
                |  g
                |
                o  5:6343ca3eff20 test
                |  f
                |
                | o  4:e860deea161a test
                | |  e
                | |
                | o  3:055a42cdd887 test
                | |  d
                | |
                | o  2:177f92b77385 test
                |/   c
                |
                o  1:d2ae7f538514 test
                |  b
                |
                o  0:cb9a9f314b8b test
                   a
              Test a metadata-only in-memory merge
                $ cd $TESTTMP
                $ hg init no_exception
                $ cd no_exception
              # Produce the following graph:
              #   o  'add +x to foo.txt'
              #   | o  r1  (adds bar.txt, just for something to rebase to)
              #   |/
              #   o  r0   (adds foo.txt, no +x)
                $ echo hi > foo.txt
                $ hg ci -qAm r0
                $ echo hi > bar.txt
                $ hg ci -qAm r1
                $ hg co -qr ".^"
                $ chmod +x foo.txt
                $ hg ci -qAm 'add +x to foo.txt'
              issue5960: this was raising an AttributeError exception
                $ hg rebase -r . -d 1
                rebasing 2:539b93e77479 "add +x to foo.txt" (tip)
                saved backup bundle to $TESTTMP/no_exception/.hg/strip-backup/*.hg (glob)
                $ hg diff -c tip
                diff --git a/foo.txt b/foo.txt
                old mode 100644
                new mode 100755
              Test rebasing a commit with copy information, but no content changes
                $ cd ..
                $ hg clone -q repo1 merge-and-rename
                $ cd merge-and-rename
                $ cat << EOF >> .hg/hgrc
                > [experimental]
                > evolution.createmarkers=True
                > evolution.allowunstable=True
                > EOF
                $ hg co -q 1
                $ hg mv d e
                $ hg ci -qm 'rename d to e'
                $ hg co -q 3
                $ hg merge -q 4
                $ hg ci -m 'merge'
                $ hg co -q 2
                $ mv d e
                $ hg addremove -qs 0
                $ hg ci -qm 'untracked rename of d to e'
                $ hg debugobsolete -q `hg log -T '{node}' -r 4` `hg log -T '{node}' -r .`
 new orphan changesets
                $ hg tglog
                @  6: 676538af172d 'untracked rename of d to e'
                |
                | *    5: 71cb43376053 'merge'
                | |\
                | | x  4: 2c8b5dad7956 'rename d to e'
                | | |
                | o |  3: ca58782ad1e4 'b'
                |/ /
                o /  2: 814f6bd05178 'c'
                |/
                o  1: 02952614a83d 'd'
                |
                o  0: b173517d0057 'a'
                $ hg rebase -b 5 -d tip
                rebasing 3:ca58782ad1e4 "b"
                rebasing 5:71cb43376053 "merge"
                note: not rebasing 5:71cb43376053 "merge", its destination already has all its changes
+               $ cd ..
+             Test rebasing when the file we are merging in destination is empty
+               $ hg init test
+               $ cd test
+               $ echo a > foo
+               $ hg ci -Aqm 'added a to foo'
+               $ rm foo
+               $ touch foo
+               $ hg di
+               diff --git a/foo b/foo
+               --- a/foo
+               +++ b/foo
+               @@ -1,1 +0,0 @@
+               -a
+               $ hg ci -m "make foo an empty file"
+               $ hg up '.^'
+files updated, 0 files merged, 0 files removed, 0 files unresolved
+               $ echo b > foo
+               $ hg di
+               diff --git a/foo b/foo
+               --- a/foo
+               +++ b/foo
+               @@ -1,1 +1,1 @@
+               -a
+               +b
+               $ hg ci -m "add b to foo"
+               created new head
+               $ hg rebase -r . -d 1 --config ui.merge=internal:merge3
+               rebasing 2:fb62b706688e "add b to foo" (tip)
+               merging foo
+               hit merge conflicts; re-running rebase without in-memory merge
+               rebasing 2:fb62b706688e "add b to foo" (tip)
+               merging foo
+               warning: conflicts while merging foo! (edit, then use 'hg resolve --mark')
+               unresolved conflicts (see hg resolve, then hg rebase --continue)
+               [1]

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages