upstream/mercurial-mirror Commit - r51712:3ccef790

branching: merge stable into default

Raphaël Gomès -

r51712:3ccef790 default

parent child

Collapse all files

The requested changes are too big and content was truncated. Show full diff

.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==
              c3484ddbdb9621256d597ed86b90d229c59c2af9 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAlz3zjsQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91XWVEACnlQCHCF7dMrvTHwE4nA+i/I1l8UfRwR3ufXhBxjVUqxS75mHMcCsOwClAa2HaqNP97IGbk2fi9y53SOKH67imNVm8NY8yIook1C8T7nKsFmyM3l63FdVQDgUF6AJ0krDt6iJo4vjk8CyRHowAcmL942jcfBU9U5/Jli11Sx33MKF/eMXnuXYRBNESh97f1bDgwydp7QT8dj/T23YvuIVtfq9h8D46qXWkpwbgtnXMnaz21kqcN6A5aKbadG4ELf9175cBlfe+ZpOqpy+OSuQBByOP5eBNl5d0vq/i4WQyJZs8GoVd5Bh559+HjKIKv11Y+gXoaQMf4VSp2JZwwPlTR5Me5N6AJNViXW1Bm108ZWeXR81Hu2+t2eQv6EelcQxnW0e/mTCUot8TaewYFJ+4VWwAAca81FP0X8J0YcdIkvvNmrU9V62B3WYK3iYgbwm7IlR3+7ilQUz3NZCZOqJpo+c7k/yhuoj4ZMDq8JzaqBnBnARbvUF61B4iVhto4xpruUQw8FwFLUuZLohsESCNCCgqdoiyJHnVQVitoNJlCeEPl+W+UUeFfwf9fzrS6nj9xWkNm9lBOahaH+fV69msi5Ex/gy8y4H+4T8z0f3gFO7kp9eKr5C7hoGyKQWv5D61H1qEZOFUZjXHBhMxbe+og40G0apMm3qmsj2KsCNDdQ==
 ada9b8d51bef24c5cb4cdca4243f0db694ab6e 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl0kn6UQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91RwND/9uZ3Avf0jXYzGT5t+HhlAeWeqA3wrQOmk0if7ttUholoHYmCbc7V9ufgiQ1jTX/58EhOXHt4L1zlLDf2OMJ7YQz9pfiGjW3vLvVKU7eeQ5epG8J8Hp4BcbEU5gfQBwzZmRMqVfZ9QbNgENysfQxhVT0ONPC5TBUsamAysRQVVPeEQFlW1mSf03LYF1UDjXgquHoIFnnPCZyNUGVRSajW9mDe0OQI95lXE6lISlBkeoTmVs9mR+OeLO3+Dgn2ai8d4gHxdCSU5iDnifSp4aaThfNxueSRFzNI1Q6R6MQrIplqFYZGhAOOXQzZWqThQld6/58IvaBP4aCGs1VxE/qBKNp8txm1QeL/ukOWPgVS9z7Iw5uRuET95aEn/Khisv78lrVGOD5wigt2bb4UiysIgk8+du7HNMqPmS31fCS1vsoJ+y2XoJP2q8bNDiwuVihDWJDlF091HH2+ItmopHGUGeHaxNyRoiSvE7fCBi/u3rleiMsMai8r1QDgBpalUPbaLzBelEKhn2JcDhU5NrG8a+SKRCzpmXkkFPhxrzT1dvEAnoNI0LbmekTDWilp0sZbwdsn2rO51IJ4PU8CgbYROP8Z4DuNMfVyVIpxAEb2zbnIA4YqJ3qcQ3e+qEIw8h9m/ot9YYJ/wCQjIIXN6CUHXLYO30HubNOEDVS4Gem93Gcw==
              e386b5f4f8360dbb43a576dd9b1368e386fefa5b 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl01+7cQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91ZM6D/9iWw0AyhcDFI7nEVcSlqDNABQvCnHoNB79UYrTf3GOjuUiyVUTwZ4CIOS+o2wchZXBRWx+T3aHJ1x6qTpXvA3oa9bgerNWFfmVmTuWWMlbQszXS5Lpv5u1lwCoLPDi4sa/gKBSIzt/CMu7zuPzO2yLEnWvR6ljOzjY9LfUx80u1zc899MEEsNuVStkfw9f37lAu+udMRgvQDZeLh+j3Qg5uh3GV3/8Q/I/YFNRHeKSLBkdp5CD3CkUtteBuZfIje/BwttxHG6MdbXMjOe0QmGMNzcSstnVqsENhEa0ZKLxM6NxfwcsxbeKA1uFoTvzT1sFyXXS3NV0noMQBwMrxipzKv4WrjuctmUms6n+VW/w4GMg8gzeUvu7rzqVIehWIBTxV8yWwkWiS9ge6Upiki5vCG+aeMLrwsNqsptOh4BEcsvcpd2ZZtUDRHYFVUK4z/RRlpKb6CdzkGeMWwP6oWAv4N0veD73Y7wPz76ZFNU2yvqViRPxrU2A2P44R8dLFvEOmcO5MHVNwHP0kpaj9dpGwBI0t2A32vDF8LEsnd86LQBm6X5ZWWJ5hGmtZotp4blkH1oFKt+ZeccHcwueIMU3v9e02ElhM4Mo2nD3yyQvMkzDqp5lZEfNqEK8rlj2TNfc8XyjAsp1hKpnjDa1olKKfdq8OniUpsaYDTku4+vuGw==
              e91930d712e8507d1bc1b2dffd96c83edc4cbed3 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl1DD/sQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91bvmD/4/QDZZGVe+WiMUxbT+grfFjwjX4nkg7Vt+6vQbjN68NC5XpSiCzW8uu0LRemX0KJKoOfQxqHk3YKkZZHIk10Fe6RSLWt8dqlfa2J9B2U8DwMEBykCOuxcLlDe7DGaaMXlXXRhNXebRheNPLeNe+r7beMAAjwchTIIJD5xcFnPRFR0nN7Vj7eRUdWIQ9H/s7TolPz1Mf7IWqapLjPtofiwSgtRoXfIAkuuabnE4eMVJ8rsLwcuMhxWP2zjEfEg68YkiGBAFmlnRk+3lJpiB9kVapB3cWcsWv2OBhz0D3NgGp82eWkjJCZZhZ+zHHrQ6L9zbiArzW9NVvPEAKLbl3XUhFUzFTUD+S38wsYLYL5RkzhlCI2/K1LJLOtj7r0Seen0v8X842p0cXmxTg/o1Vg3JOm04l9AwzCsnqwIqV7Ru//KPqH91MFFH6T6tbfjtLHRmjxRjMZmVt7ZQjS84opVCZwgUTZZJB2kd1goROjdowQVK6qsEonlzGjWb9zc3el5L9uzDeim3e5t2GNRVt8veQaLc+U2hHWniVsDJMvqp2Hr9IWUKp+bu/35B1nElvooS40gj2WhkfkCbbXSg9qnVLwGxxcGdF28Z0nhQcfKiJAc+8l9l19GNhdKxOi4zUXlp90opPWfT7wGQmysvTjQeFL2zX9ziuHUZZwlW1YbeMQ==
              a4e32fd539ab41489a51b2aa88bda9a73b839562 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl1xTxUQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91ZQgD/96mViQ6fEh84l4XyAlY6Dq3SgMqEXttsUpk/GPoW4ykDFKN6VoiOaPoyNODO/46V3yeAjYjy3vX7Ua4/MY1NlnNoliQcTYtRV3SlDdoueTPOLfO6YSV27LG+dX/HYvPc/htCVmIVItU1JL+KEpXnv+bT50Bk+m6OgzfJMDzdHQ5ICImT8gW7UXlH/mlNtWMOrJDk3cArGhGs/pTFVrfgRTfDfDGSA9xW0/QvsNI5iwZHgMYaqoPFDnw6d/NXWRlk77KNiXkBEOKHf6UEWecMKmiSCm8RePSiX9ezqdcBAHygOg4KUeiR2kPNl4QJtskyG4CwWxlmGlfgKx07s7rGafE+DWLEYC9Wa8qK6/LPiowm17m/UlAYxdFXaBCiN0wgEw7oNmjcx/791ez+CL1+h6pd0+iSVI4bO9/YZ8LPROYef18MFm+IFIDIOgZU4eUbpBrzBb3IM1a519xgnmWXAjtRtGWEZMuHaSoLJf2pDXvaUPX6YpJeqCBFO3q/swbiJsQsy6xRW0Dwtn7umU1PGdmMoTnskTRKy9Kgzv7lf/nsUuRbzzM4ut9m1TOo27AulObMrmQB4YvLi/LEnYaRNx18yaqOceMxb/mS0tHLgcZToy9rTV+vtC21vgwfzGia2neLLe50tnIsBPP/AdTOw9ZDMRfXMCajWM22hPxvnGcw==
 e52f2b62f4768aa0d988936c929dc7c4a41a0 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl2UzlMQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91SDzD/0YZqtN+LK5AusJjWaTa61DRIPhJQoZD+HKg4kAzjL8zw8SxBGLxMZkGmve9QFMNzqIr5kkPk6yEKrEWYqyPtpwrv5Xh5D4d8AKfphdzwSr+BvMk4fBEvwnBhrUJtKDEiuYQdbh4+OQfQs1c3xhtinjXn30160uzFvLQY6/h4hxai2XWj4trgoNXqPHDHlQKc6kRfPpmNO2UZhG+2Xfsava2JpcP4xA2R0XkI10be5MDoGU4AFCMUcXZzIto0DYT+HOezowoNpdC1EWVHfa+bdrlzHHO7WPaTLzEPy44/IhXmNhbwFKOk5RZ/qBADQvs9BDfmIDczOoZKTC5+ESZM0PR2np5t7+JFMUeeRcINqBdSc4Aszw3iHjgNbJJ3viU72JZvGGGd9MglP590tA0proVGxQgvXDq3mtq3Se5yOLAjmRnktW5Tnt8/Z3ycuZz+QsTEMXR5uIZvgz63ibfsCGTXFYUz9h7McGgmhfKWvQw9+MH6kRbE9U8qaUumgf4zi4HNzmf8AyaMJo07DIMwWVgjlVUdWUlN/Eg61fU3wC79mV8mLVsi5/TZ986obz4csoYSYXyyez5ScRji+znSw8vUx0YhoiOQbDms/y2QZR/toyon554tHkDZsya2lhpwXs8T0IFZhERXsmz/XmT3fWnhSzyrUe6VjBMep1zn6lvQ==
 f9561099de77c684c00f76507f11e46ebe8 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl2ty1MQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91XBUD/wJqwW0cuMCUvuUODLIfWa7ZxNl1mV9eW3tFQEuLGry97s12KDwBe0Erdjj7DASl4/6Xpc4PYxelZwSw4xT1UQg7wd/C3daCq/cDXrAkl7ZNTAHu6iAnHh25mOpIBfhMbh4j3YD0A2OoI17QGScU6S7Uv0Gz1CY20lJmEqsMzuuDPm2zrdPnTWffRUuPgskAg3czaw45Na7nUBeaxN1On0O5WqMYZsCGyi14g5S0Z0LHMKRJzc/s48JUTDjTbbzJ6HBxrxWTW2v8gN2J6QDYykcLBB9kV6laal9jhWs9n/w0yWwHfBfJ+E4EiMXeRdZgGA55OCOuDxnmmONs1/Z0WwPo+vQlowEnjDMT0jPrPePZ5P4BDXZD3tGsmdXDHM7j+VfDyPh1FBFpcaej44t84X1OWtAnLZ3VMPLwobz9MOzz4wr9UuHq23hus0Fen+FJYOAlTx9qPAqBrCTpGl+h1DMKD62D7lF8Z1CxTlqg9PPBB7IZNCXoN7FZ4Wfhv1AarMVNNUgBx6m0r6OScCXrluuFklYDSIZrfgiwosXxsHW27RjxktrV4O+J1GT/chLBJFViTZg/gX/9UC3eLkzp1t6gC6T9SQ+lq0/I+1/rHQkxNaywLycBPOG1yb/59mibEwB9+Mu9anRYKFNHEktNoEmyw5G9UoZhD+1tHt4tkJCwA==
              ca3dca416f8d5863ca6f5a4a6a6bb835dcd5feeb 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl3BrQ4QHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91ZXjEACfBdZczf0a4bmeaaxRwxXAniSS4rVkF790g22fsvSZFvQEpmwqNtsvbTt3N1V2QSDSZyhBa+/qfpuZ689VXMlR3rcJOVjo/7193QLXHOPfRn7sDeeCxjsbtXXLbLa8UT56gtT5gUa4i0LC2kHBEi+UhV9EGgSaDTBxWUFJ9RY2sosy1XFiOUlkUoHUbqUF28J3/CxEXzULWkqTOPwh94JYsgXSSS69WNZEfsuEBSPCzn8Gd7z7lWudZ/VTZBTpTji7HQxpFtSZxNzpwmcmVOH9HlEKoA1K4JoR+1TMHqSytQXlz3FMF6c6Z1G+OPpwTGCjGTkB9ZAusP3gU8KIZTTEXthiEluRtnRq1yu4K2LTyY172JPJvANAWpVEvBvn4k5c9tDOEt9RCAPqCrgNGzDTrw02+gZyyNkjcS6hPn+cDJ6OQ1j2eCQtHlqfHLSc7FsRjUSTiKSEUTdWvHbNfOYe6Yth/tnQ7TnpnS9S0eiugFzZs2f8P85Gfa3uTFQIDm67Ud+8Yu1uOxa6bhECLaXEACnLofzz8sioLsJMiOoG2HmwhyPyfZUHXlb2zdsSP3LC+gKN39VvzSxhhjrIUJoM4ulP0GP1/lkMVzOady66iLaEwDvEn4FLmu395SubHwbre1Jx83hiCQpZfPkI0PhKnh4yVm+BRGUpX97rMTGjzw==
              a50fecefa691c9b72a99e49aa6fe9dd13943c2bf 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl3pEYIQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91duiD/9fwJbyrXXdpoBCeW3pgiz/xKZRQq0N3UqC/5m3PGl2qPfDqTi1GA6J+O24Cpy/FXYLEKlrEG2jy/iBZnGgTpb2sgycHFlWCT7VbuS8SDE3FFloTE8ZOGy5eJRo1UXYu4vsvNtmarN1xJQPrVK4l/Co5XWXFx15H/oMXLaHzS0kzQ/rHsMr7UXM0QwtmLC0S9IMetg5EUQx9GtHHaRnh1PIyP5NxP9VQ9RK4hmT6F2g60bcsMfpgF0I/RgL3tcdUn1RNIZ2OXHBhKYL+xOUe+wadDPIyPDqLXNEqPH7xqi0MQm/jOG++AvUPM7AdVc9Y2eRFOIIBIY0nkU5LL4yVVdqoc8kgwz14xhJXGTpMDRD54F6WrQtxhbHcb+JF7QDe3i9wI1LvurW4IIA5e4DC1q9yKKxNx9cDUOMF5q9ehiW9V120LTXJnYOUwfB7D4bIhe2mpOw8yYABU3gZ0Q6iVBTH+9rZYZ9TETX6vkf/DnJXteo39OhKrZ1Z4Gj6MSAjPJLARnYGnRMgvsyHSbV0TsGA4tdEaBs3dZmUV7maxLbs70sO6r9WwUY37TcYYHGdRplD9AreDLcxvjXA73Iluoy9WBGxRWF8wftQjaE9XR4KkDFrAoqqYZwN2AwHiTjVD1lQx+xvxZeEQ3ZBDprH3Uy6TwqUo5jbvHgR2+HqaZlTg==
              b4c82b70418022e67cc0e69b1aa3c3aa43aa1d29 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl4TkWgQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91aV6D/4xzlluOwsBhLXWUi7bDp4HtYnyDhq4XuDORAMO5mCZ7I7J6uqGoViqH4AhXoo3yPp1cDiRzzl172xpec38uTL8C5zHhARKuAl5Pn1A8rYORvYzT9nsDh4MAtfTokhg81awRzhun9xtPUT2nETAOgampW0g7r241MSR1j0myAkC7zqO3yf+1rYo7kiv7fh+74MkrSn4HEmEaLsI5gW05tFR+ip6vpm6eikFinqeVJegDCuyTPMvH0D9ZeBNlyoOfdEd6DDYsWvWAmLSO9FGbb03R5aOFRp7RmQRFH/qcueeePa/9Z1zO+YyCeBy0wvWCkjfLMY99HhNhdNfy/qC/69V5RGQYvaapy6BEAi4eCH73hsxzCQpKopUl9VrpwhNasJ41KWc90RsPO91bkTdDddF7e2qjq762aNgm7ysEzIHMgSsMgsE9w8hz70RE7bk/gYn26ak3XP4nCOY0OJQ8mgaElN/FP1kxqqT7MM7WeMiNMFTD1gvWwEAu9Y47AwUedkTrykQsAFzc+CyaIaW+/Kuyv0j5E7v8zAcVTTX4xIyqR4yL2Nwe1rYE4MZgs0L9gQ3rcdyft6899gAiiq96MPR3gLJUPbBz2azH/e0CzNXvDJa39jIm2ez0qC7c88NhTKhFjHE9EW5GI3g8mhS5dJXCnUSq4spgtrJdfGenL3vLw==
 a0102c05c7852c8215ef6cf21d809927586b69 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl4nP/4QHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91VaHD/93dVKKFMJtclNMIG2AK3yZjfQ3HaqIuK1CqOuZyVQmk5fbnLydbi5RjIQMkaYPSKjDz0OKlfzDYo6kQrZrZUzIxzPBOz8/NMRSHGAWqvzQMbQGjYILsqDQ+wbol9wk8IDoyFzIcB4gPED1U5kWVCBTEqRrYiGP4siiycXVO5334Q5zOrvcjze0ksufbKQhL6SEUovfLtpX+DW6Z841LmR53aquEH8iBGswHKRt4ukyvmXTQAgea4lWXZXj3DH6oZqe0yzg5ogF4vFaoIgZDpBh2LZKuh6gwJtvA9jsFj5HVOzYDcllkgpaOTV1g/xKPo1EkLpt0W0vd/4vnjSKNo0fmOTvZzI9vCCXLlRSUhoboY6AFHN7XtL9gYWI0rj81p/WrnnQQ7Iv2YHS1KCLr765HW6mjREwFMLD9RrLLDQ0DWIyNuGq8/yrqoruAhidEE9ifITnNh38wVISdiPxORj3onZkAn7VbOWQnlJtYkynlk2t3HnHWfduLGc2G0BkLvg4YfEDsZBA+ssr+TspkZ1dVAq8kf4JKNR01sfjBF6Fj1zRPkoexV40/pPiW55ikfOI9LRHxRiOUyndLviIBv1Mbm90PZ89lT4OTMejD8hhb4omlVxH3HFv4j7TozuPFOuouH7ARRwbPFl/0ldPlESoGvFiyOrqNzlql+JvyLUSbg==
              e4344e463c0c888a2f437b78b5982ecdf3f6650a 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl4rFTIQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91eStD/wNSk7/07dvzItYmxg9LuUInYH17pZrXm8+jGEejoYZw74R1BHusFBcnmB1URldbq4IdzlxXNKrcnmJH/lgYCdbZ8OG0MaQrEIyLz0WmY27ARb/AwDuiy/dn0X3NgvQjqPffLHrYHmdqvqBsb0+qG3v7b0xt+BGDkebt1TXCy9wjIa1iqCOQ0EJi2dcuD2dWlhPM2kuslMjKlqe57D5bwaHBDS6K9Sd4VABRdv7mExrMBSr1SnkasrBsvb47UVXYUJRI3GGyA/wYYAi3fW9ZxG25x2SA0rjF5U68c5rmQMD94FLmaSoaqSvigkSBDOF/DIwlRO5vB4NlP7/+TjNOo92r4GbTZyMTnrsORqQJKcMrpfVbM8gRngPTJz2FxBSoz86HQ3wVXnS0gVUJNM+ctWdvzvtrv1Np3wF0/zWHddrtfYdNgnuyKjQL3chpJs7y5aQxdgU1vHdf4X2NwhA77Cf/U6bSemhR+MfZlp4it7pZiu96b8jKsEbKrCi998tKCKVv70WhGXce3gebKPY3Gn/qUL6X3rx4Uj5CPrIjWZNhwRJJ3BXSTnKog2eUIWJC0rXXrGRV6Sf6514zbi0MCOexnAjZM1xs5NUd/wrugDnMp4+P+ZPZyseeVB51NSnGhxlYLwD9EN+4ocjyBzMINOcQw1GPkB5Rrqwh+19q5SnvA==
 f5410dfc8a64bb587d19637deb95d378fd1eb5c 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl44RUUQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91WcUD/9em14ckTP9APTrSpe6y4FLS6cIUZabNN6wDXjTrHmS26hoNvWrT+RpWQ5XSOOJhZdhjkR1k87EOw9+m6+36ZaL+RXYnjrbku9fxbbFBraGTFy0JZHAT6v57uQ8P7XwqN4dGvXXpgE5UuY5sp1uDRbtIPNts3iWJKAnIazxUnyotHNtJQNESHySomzR1s93z1oOMpHapAqUmPbcZywg4otWjrOnkhOok3Sa3TgGthpHbM0qmh6J9ZaRBXsKEpLkjCRNggdvqww1w4omcAJzY4V5tG8WfhW+Xl8zBBe0K5m/ug3e25sWR5Dqm4+qUO0HZWQ3m3/M7CCuQrWFXTkr7nKac50vtFzsqHlHNoaiKnvQKoruQs3266TGsrzCCOSy8BqmpysD6sB79owLKoh0LfFOcSwG9kZ8sovEvTfrRn8g3YAp7XbXkDxbcLMijr7P4gWq8sC1NZJn1yhLXitcCfAAuVrVQfPVdt2pp8Ry2NdGnHjikQjOn/wAKlYJ5F8JMdn6eEI/Gveg2g8uR9kp/9zaXRx6rU3ccuZQ7cBQbBlBsmmpd7gJRp2v0NKsV8hXtCPnBvcfCqgYHLg7FQVq1wKe5glvtmx9uPZNsl/S++fSxGoXfp9wVi048J42KyEH6yvoySCvbYeSFQvMfAoD1xJ4xWtT8ZEj6oiHvzHw1u/zgw==
 d121acbb82e65fe4dd3c2318a1b61981b958492 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl5f3IEQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91WoeD/9qhywGg/TI/FJEeJN5bJjcpB/YQeYDWCHh69yUmMPenf+6CaV/3QPc3R8JyQSKWwGUwc0IgZiJBb/HoUvBzpQyTvmGqddWsIGBpdGAkbLmRrE5BakR7Shs987a3Oq4hB03DJD4sQ1VitWg2OvGNd8rl1kSIF8aIErVI6ZiSw5eYemc/1VyBJXHWSFmcfnQqdsyPppH9e9/TAhio+YP4EmLmoxUcyRSb3UbtO2NT9+DEADaex+H2l9evg7AkTieVd6N163uqsLJIxSfCh5ZVmzaGW6uEoyC4U+9bkAyVE3Cy5z2giYblBzUkO9xqEZoA4tOM+b+gHokY8Sq3iGVw046CIW5+FjU9B5+7hCqWThYjnpnt+RomtHxrkqQ9SSHYnEWb4YTHqs+J7lWbm3ErjF08hYOyMA9/VT47UAKw4XL4Ss/1Pr7YezdmwB4jn7dqvslNvTqRAUOzB/15YeCfbd23SL4YzGaKBs9ajkxFFeCNNpLQ8CRm3a7/K6qkYyfSUpgUX7xBmRQTvUgr3nVk1epH/kOKwryy94Z+nlHF0qEMEq+1QOa5yvt3Kkr4H03pOFbLhdpjID5IYP4rRQTKB9yOS3XWBCE63AQVc7uuaBGPMCSLaKRAFDUXWY7GzCqda88WeN5BFC5iHrQTYE1IQ5YaWu38QMsJt2HHVc27+BuLA==
 fca7e8449a847e3cf1054f2c07b51237699fad3 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl6GDVQQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91egzEACNEyQwLWCQEeNyxXKuTsnXhYU/au7nSGOti/9+zg/22SSceMsVcIyNr2ZnkMf3hnzBjL7Efsthif0QXyfB0LZDXwNuDmNlDtUV2veyVGSDE2UqiSbDBRu6MYTvtfYX87RmSWla3HHO09pwpcrhxyHs3mliQsXyB2+D+ovTOIjYukQLnh34jQnwiWEYLDXkHEHHTpdXqAnA7tVen3ardLyTWgky6DUwlfcnoVsAPXnDkqQ9aE2w7SoAsNtEAddmkjKoYYdBkV5aUInU/DyFVF7qnlCcvWm+EkN1708xZUQ1KzdAyeeoIrMkBgpSoyeNQ9pcU3T7B100UxLo/FP/A7y96b2kHnKJU6fVyD3OeHvP9SeucurC6jn2YoG3e1wSOQcbEuCsdGjqgAHnKt2SMPsEBu2qJJcUdco9tANN5BdntBo7bLc/zcpXZH3TkRfRSndWXPaXDJaQNvbH7aLIUTCP9oQaqTN+9BQ+Egt7YsB4C58JZmC87FAuekDULc4LWK2gDPFf7F/PvBnMh7+YylPl/8LLrEnz2Q/GM0S1HLhBrDf6vzxV5wVzCu9Q2N0PCkg6lDAJFVWLTEbxcRukKxbyK88Yzrb4GuUY4F5V21fN4vuxkOay7eoiXUcHMN2IN+DwhNWQSm5pUnpqGTfCYj/ZBbAykP2UnVOClL6O2JQA2A==
 ce8e7515036d3431a03aaeb7bc72dd96cb1112 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl6YlRUVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6Z3YP/iOqphn99v0z2OupCl0q8CepbcdZMJWW3j00OAHYSO43M0FULpMpzC2o+kZDeqeLyzN7DsjoGts2cUnAOe9WX73sPkX1n1dbiDcUSsRqNND+tCkEZMtTn4DaGNIq1zSkkm8Q7O/1uwZPnX6FaIRMBs9qGbdfmMPNEvzny2tgrKc3ra1+AA8RCdtsbpqhjy+xf+EKVB/SMsQVVSJEgPkUkW6PwpaspdrxQKgZrb7C7Jx/gRVzMTUmCQe1sVCSnZNO3I/woAqDY2UNg7/hBubeRh/EjoH1o4ONTXgBQdYCl7QdcwDHpDc2HstonrFq51qxBecHDVw+ZKQds63Ixtxuab3SK0o/SWabZ1v8bGaWnyWnRWXL/1qkyFWly+fjEGGlv1kHl3n0UmwlUY8FQJCYDZgR0FqQGXAF3vMJOEp82ysk6jWN/7NRzcnoUC7HpNo1jPMiPRjskgVf3bhErfUQnhlF1YsVu/jPTixyfftbiaZmwILMkaPF8Kg3Cyf63p2cdcnTHdbP1U6ncR+BucthlbFei4WL0J2iERb8TBeCxOyCHlEUq8kampjbmPXN7VxnK4oX3xeBTf8mMbvrD5Fv3svRD+SkCCKu/MwQvB1VT6q425TSKHbCWeNqGjVLvetpx+skVH7eaXLEQ3wlCfo/0OQTRimx2O73EnOF5r8Q2POm
              cf3e07d7648a4371ce584d15dd692e7a6845792f 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl6sS5sVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6FQcP/1usy9WxajBppBZ54ep+qesxufLoux5qkRU7j4XZ0Id4/IcKQZeik0C/0mFMjc+dYhQDGpDiuXCADKMv5h2DCIoaWUC0GueVtVkPhhMW3zMg/BmepV7dhUuipfQ4fck8gYuaBOclunLX1MFd+CS/6BQ6XIrsKasnx9WrbO2JpieBXv+8I5mslChaZf2AxeIvUVb2BkKqsCD0rqbIjTjtfHWJpaH6spFa7XX/BZWeEYz2Nc6LVJNZY0AmvJh8ebpoGOx85dokRIEAzTmBh04SbkChi+350ki6MvG3Ax+3yrUZVc1PJtBDreL7dMs7Y3ENafSMhKnBrRaPVMyUHEm2Ygn4cmJ1YiGw4OWha1n7dtRW/uI96lXKDt8iLAQ4WBRojPhYNl4L3b6/6voCgpZUOpd7PgTRc3/00siCmYIOQzAO0HkDsALoNpk8LcCxpPFYTr8dF3bSsAT9fuaLNV6tI2ofbRLXh0gFXYdaWu10eVRrSMUMiH7n3H6EpzLa4sNdyFrK0vU4aSTlBERcjj2rj86dY0XQQL181V7Yhg8m8nyj+BzraRh7et2UXNsVosOnbTa1XX0qFVu+qAVp2BeqC4k31jm0MJk+1pDzkuAPs07z3ITwkDmTHjzxm5qoZyZ1/n37BB6miD+8xJYNH7vBX/yrDW790HbloasQOcXcerNR
 cbdbdbb05dcd6bb814eb9bbdd982211b28 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl7amzkVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6AKEP/26Hoe8VqkuGwU0ZDsK6YgErXEPs8xtgZ9A2iouDkIqw2dm1TDmWnB5X8XaWmhAWFMUdjcqd1ZZJrAyD0p13xUOm3D+hlDXYTd2INkLwS8cVu22czZ5eoxtPkjuGYlPvek9b3vrrejkZ4vpamdS3iSvIx+TzvEW+w5eZFh9s1a9gR77hcZZoir24vtM9MsNnnBuI/5/fdWkhBoe17HSU4II56ckNXDrGO0nuqrWDxPr64WAcz6EmlTGc+cUqOM45Uc0sCr3GNQGEm6VCAw5oXq2Vt9O6sjgExLxr8zdud6w5hl9b8h2MrxyisgcnVR7efbumaRuNb8QZZPzk5QqlRxbaEcStyIXzAdar4fArQUY2vrmv1WyLJR3S/G3p8QkyWYL3CZNKjCAVxSa5ytS5Dr/bM2sWaEnIHqq+W6DOagpWV4uRRnwaId9tB9b0KBoFElXZRlaq0FlNYG8RLg65ZlkF+lj6RACO23epxapadcJwibDQiNYX20mcSEFDkSEgECnLQBecA2WZvw134RRbL3vuvB49SKS0ZEJ95myXMZa9kyIJY/g+oAFBuyZeK9O8DwGii0zFDOi6VWDTZzc3/15RRS6ehqQyYrLQntYtVGwHpxnUrp2kBjk3hDIvaYOcFbTnhTGcQCzckFnIZN2oxr5YZOI+Fpfak6RQTVhnHh0/
 ea9c86fac8974cd74dc12ea681c8986eb6da6c4 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl78z0gVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6IrkP/2m/DJ93BR/SljCFe7KnExrDTzDI/i69x+ljomRZJmMRa86zRkclgd5L49woExDd1ZGebUY650V16adKNmVpz2rS6bQOgEr2NBD5fL+GiTX6UJ1VMgmQ8x1m8DYuI8pfBWbqQuZIl1vCEc0RmT3tHLZ7T8XgG9RXa4XielI2uhyimJPyZsE1K7c8Fa6UakH++DhYFBj+3QYbwS2fFDdA29L/4N5JLUzHkIbF7tPg7P1RBk+vhopKz9MMIu4S95LU+Gk7eQ3FfE8Jnv959hX2o/B2sdT2tEPIuDRSxZhSKLdlGbMy5IZvc/bZ+a5jlb2w23tlpfgzQxNarFqpX/weiJCtsxzeMXQHEVFG/+VuIOIYbfILWzySFcnSvcAtmNXExxH2F9j+XmQkLysnsgIfplNVEEIgZDBPGAkAQ+lH7UrEdw31ciSrCDsjXDaPQWcmk4zkfrXlwN7R9zJguJ+OuZ/Ga7NXWdZAC+YkPSKAfCesdUefcesyiresO8GEk9DyRNQsX/gl5BjEeuqYyUsve5541IMqscvdosg6HrU/RrmeR7sM7tZrDwCWdOWu/GdFatQ+k6zArSrMTKUBztzV93MIwUHDrnd+7OOYDfAuqGy7oM2KoW0Jp8sS2hotIJZ9a+VGwQcxCJ93I5sVT6ePBdmBoIAFW+rbncnD+E/RvVpl
 c5de797e5416f9b588940f4608269b4d50a 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl8VylYVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6zUEQAJoLrpMmHvM4VYepsu2UTFI2VA1iL7cd+AOlcAokn/29JOqmAWD2ujUMv2FIdcNqAW/ayeEW9oLAi0dOfLqS6UAxfw8hYEiM6hV1R0W9DOUV5CRQ5T86cbaZFBrrJL9N87tHjro0eS3i8iwPpklnWrwf8fkcBq8SKFBZbubat8X/mejbbq6zYML9SEhtrKHyBPL5iQjzqDEGWyTqJYusHGVkAtFMZWxStDA3VSr3x9Iy0495XdegYRkUFytRsz1zB3vfawJsWRY7tQfff5CF6knZ+UIpetjgJIlm21/vQmcL1aTIxem0CFQt5bub1a+LYI1TWt59rFrnRj97K6Kq6xG6lPjnM3l/w2nehGfpL/Tfjih9gY8ToS1GRg2JJ4IiXAI57fv5fZcZv3R0xAGfWfRdwMsO2siaDrd4R/kraDlTPZZ1Qmpa+Y4XtFxSGIXtf9DWt/7pw81GWrUH0u/WYjfSpYvbdr7GvYpdzxMmtEULoxJ9ibyFDyDyqEkJfT6onFb1aaHQJ1mjho1x93uDeAEq0R5UCSNDxi31Hq/nWtA9IwCjYeQkv9D1rxFcSx3MetUpJofdBYvvFsvjNTM5GO2ETvsjyzXf2Qa3oobQoKBqbTuKR6yJlCsmWJuejbDbblBdx3mj4xpXxmX/YQHQ+2PYrfopel/8Am8j7sq0sNcV
 fc3c5fbc65f6fe85d70ea63923b8767dda4f2e0 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl8oTNkVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6YLIP/0ZRwrBhBrMsy4UDS6dBwJ2WS5MRFIGTx44TW5Km/QGahz8kU+IEnKcV3Q9K7qu6Navt4uFvwFxJxDebcl4TJMfLqXH8gp8cma3GHLcHEgdms+lWe7osVVfDsynnSpZbwzUgeHoiJz805BAPrpesfq8GUDzeONJJcVtbAanSg+E0tnFNUE3592Oz8VjvgBAlPMdaRiPiTs2FrEN6+h1zxgHRSY8q4ZC88y1x5dst2yjCef9SUQ5MW1OCMuy+ki3QSwxRZfa28Z+17sJ6Lfy2ZqE2J7dZquGXllF6wPYGHmUZ1NKu4gY9aIghJBUzk6gZgvoqlJ44jFSlw4+Q8k9UW8GgLrMOkKCGstTztHDXdqCU4FMpUP+SaMq/XN4XRiyw5FiYyhBaCF3K3QwGqYNP4jadZqYAe1/UnjLWoPN5ZiXZQW7yD5MwOtrZOJFmm4PuFaAAPy4cdSvHpVA8HVQWyLhE0BSA7r8spPVptP3w9GG+qEGR3pvs0mVjMOVI/nWNuD40PILtGqqhbBIUawKqxtfdA1Pf1qcxWTC2Uxgtw0YuMHztPWihW0xfDxxdZ13ewQ4ETdWj598CyaUs3nVRX4ru33pmWBfhLSlXRsNhqc7N7XJ0xE8eHIUs7F3WCwBjMMemV6K3HN0xT4b+7uDdw2RuUA2HGtKLzNAGN9gyMd6/
              f62bb5d07848ca598aa860a517394130b61bf2ee 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl9OKQ8VHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6fZ8QAJrThdhW9z05KenVuMDofakaCK0MGjSu4Tjg0D5vcVSOi8MGUU1XLky7T8HGhCZvGS2WWsqWenfj+BigXz1Ri4Iw5/j9WE2e7K1tu4if3ZTWrrcwtGgVL5ABnqJ7i9N3SxAIZ8+ws+UkZ4qdd33YsdJesY00Hzk2QJcPCI8VMINeDedh+EQZAcYYD0T5oWYBttHn+xzk7GROL3LJLoZK6YiPigd0ZpWnJJvZtjH8S9SenVNsa0FFGvjbe4tYQz1AcJxc9J7onBkzSPDONdeONWItyaLUF/luvtgfY84OigHpnR1W+h11HfwtPlXMNP21kV2vyN8aLR1Zplx2QNZXykwm2zpD/3MZROb+OjTq/FmKACdgtylCL7vm0fQwcGoydKryuFw08b0EKSS4YQ6qIakh8d1Cz5WKMlvzd/TudoW+MNOChFreN9db2mYSxjHrtqeDp7I8uV1JdtC+UXPtBNXIOddg1/C2V2X7palfscrLbIFAVGsUf6x4AeGjatuxUUxrp0flEjH4IvRIuhwv1QSdLTJQCq3zMoosPgRskETlgqrjZawxWspGNbXOX45YWb+vEib17c11OE0C5vQFtA6q6MDO/g/g95eVGijIxUiLM45Nh7O+e7ugHiFwWQiD5KlVz1w5QRsCfIdYPOXXUEMyVDE94WduEHB+2D1FZ8hi
              07731064ac41dacdf0ec869ebd05c2e848c14fbf 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl93L8cVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6xZIP/R34y1j74tumvkIQhijDuMEar3mEOcA0Bjy2iLMjEJtIwQ7OqRbQRY4bn5c88+uQtP2W2KH7OY8tusy+zplkclP2YZUMfUfeClz0G9Ud+94+hs41TX60Htm2dM3UbDo6aCO/j8Ado0U8W7m6LDd1UR/4UfcM5q2YZAq4n6a4twJuDqlv6xx9nFRK8AbeKihIGzv+J46YrqWi9unmLc0kTb6qWT/7H2FeMeBNN+XfGZ+ry/zEyTdhyURTaWEvt6h4EnroPFRmb779aK7dFNDZvc30bh5CnBfGflvvl5sQLDOU7Dqjmhie+PdVK0XNr1PGxNbI2Y9RSKyKXKHRI4jgxHfsB1957cVD++rzSBs4nAockPlAqupK8wL/RWZ0ilB+un1zPizk67cwApnQcWIRro+6D4OuqhA98DAHLu9R7vsjArxCcmgHXdjMiOpLs2K5dqYG15bgeJ+csVDzgFs8vtiaXWYbDdHrhMMAx0V+tLb9Yh6CashwPmi8+7mroJgqtZTLPg4cRwj0TiuHXzLUQrAzjf2o48KiUCEx6pz7PdQtaePO/l2qJCBWuXhY7pSNLy3kHv1gFN+hqKHLdJVNMoF0aR0O4u87ry7SD1dvz90BshH9kHy8FR3q77ITNVNFghWzNp4faTdqiNMMtx4fw+j28G5yQS3hmCkApmti9zJi
 e06a7ab9e0d5c65af4e511aee1e0342998799df 0 iQJJBAABCgAzFiEE64UTlbQiPuL3ugso2lR0C/CHMroFAl+PEggVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJENpUdAvwhzK6KGoP/3rNBknIuLpJ/+nWiTQNY3GsJwl1Z0QX97cpXevNYQDjNGFpOJveJwEKq5ouAfD+bLILuEjdgdMaB/87b1fuf4stsH3myG6PlvgXeP9cpEMGejh4UvLBO74l5qALYI5J5f7/M8tPN1VGSC0cAcSvRilh+zl8KXakCjz/zoVpdDwE9YsbdZHhYMe2aiGJw0tueao22kP7txuqmy6coHVHIHhxLhvZ/HGSjoUD+oCcBVw9dIReariUFWw+56MAhAf99JhiQ/In+w1qKcoLF64Y7m45Tl7MPsweCpVQ0wtoprOMFziYhmwZcPPTa4WnNbE2MbnJcKyCKF3t3dJqqEplp64KYjskckZlK6lbhLrAi/nGU6HNRCRjIyzcA4qPhaEYb8DnebBPCpuKMaZMyJCZd+N7ydDAujGa+q2U5O1t1nLBRMou7eXD86L3aH2mukbUkkGmZXUP6M1C4ErEPZU78QoqUr+A+74+y+2lgWdkXYv5QmApitGMIel1sh80XYcdZmNAeXzB3QL3KnYp+mDapSe6oKAcArHWzbrCm4zWng6B6JKV+rHfbb9dxdJ3cSJwY+tTZQHwHZkQFVxiJsw2ID5jZsFwKkfXhqLW3FY+u20WQriVF5EDahdy5VvhNbsEVTY42m7OAUK7FjVqyX+gvtNx/mhyoPOv+6P+oPMj1HWa
 c17d63fdabd009e70bf994e5efb7db422f4f7f 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl+gXVsQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91SAmEADN4fJHjY+Gxu4voL7BHCW3iar3jqyziY+q681nGBK6Tr3APslQkENFahAyHPawkuyiznfWVzzQh/aSbvqDDYCUe+ROjsjSGOwmyd45CN4X01RF1gavuCD5iAn5nw/PML4owtHkM4MhSI0V3++GgczFiDrG09EfGt4XxPWJT5XZaeR4uLB+FJL1DjuJQx8KTZDdlPsLzUCh41l76wrYRqP47KNtm50co4MJOx7r6BQn8ZmfNxG+TBnNRasES1mWv8OtYTleHZPHjvxKXmXNwuCPg1u33vKGIM/00yBm9/KHnfPUnLDxVXIo7yycLtU7KVXLeY/cOG3+w3tAY58EBozr8MA8zIAY773MqFq+I5TRKTQAxzpTtWm6FeW6jw1VAN4oImaWKWuKqIs7FbTwtw6158Mr5xbm7Rd7al8o9h8l9Y0kYyTWdzNnGCRGsZJ9VRnK7+EJ7O7PxicY1tNzcqidP/CvS7zA6oCeOGhu5C79K0Ww0NkcHcIeMznM1NK+OihEcqG5vLzuxqRXB93xrOay+zXBk/DIr0AdRbXUJQ8jJR9FjVZMHFTH2azAvBURsGwmJcJWIP5EKg2xNl9L1XH2BjwArS7U7Z+MiuetKZZfSw9MT2EVFCTNFmC3RPmFe/BLt1Pqax1nXN/U2NVVr0hqoyolfdBEFJyPOEsz4OhmIQ==
 d5189a57405ceca5aa244052c9f948977f4699b 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAl/JMCcQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91d8VEADPmycxSrG/9WClJrXrZXVugf2Bp6SiKWarCWmZQ32sh/Xkl6Km8I6uVQL0k82lQO71jOin6APY2HJeOC57mBeX9HOPcN/l+I8g4HecdI6UO8+tQzPqzno92Nm+tj0XxSelmMZ1KwDYpiHBo8F9VMILTZSdFdC5zBBMQOHhJDAtIUJx5W8n2/mcDvFEpv5OHqS2kYzHHqn9/V+J6iOweP2ftd3N84EZZHb7e8hYbLHS1aNJRe7SsruCYJujHr8Ym5izl5YTpwvVCvudbK/OnrFd0MqT3oRS8WRPwwYcYJkj5AtDLA0VLbx47KeR0vLCC7hTkFoOtFtxc7WIJOZVb/DPi38UsSJLG2tFuSvnW8b1YBCUD5o39F/4FxUuug/JxEG3nvP0Hf6PbPiAn/ZPJqNOyyY51YfjAaAGZeP+UNM4OgOdsSq1gAcCQEMclb54YuRe/J/fuBkQVKbaPuVYPCypqdc/KppS9hZzD3R3OEiztNXqn8u2tl33qsvdEJBlZq9NCD/wJMIzKC/6I5YNkYtgdfAH+xhqHgPvohGyc5q7jS8UvfIl6Wro8e+nWEXkOv2yQSU8nq/5hcyQj5SctznUxArpAt7CbNmGze42t29EdrP4P5w2K6t1lELUw1SVjzt/j9Xc5k/sDj4MxqP8KNRgoDSPRtv7+1/ECC4SfwVj5w==
 da65e3cf3706ff41e08b311381c588440c27baf 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmAHEb4VHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfMJ0P/0A0L7tLfx03TWyz7VLPs9t3ojqGjFCaZAGPyS0Wtkpw0fhllYzf4WjFyGGsM1Re8fY7iakSoU3hzHID9svxH1CZ2qneaWHyXc166gFEhvOUmySQMRN26HnRG2Spc+gc/SMLUcAavzMiHukffD+IF0sDwQyTxwei40dc2T2whlqlIJ5r3VvV9KJVWotupKyH4XcWC5qr5tQvoc4jUnP+oyRtmv9sr9yqoC0nI6SALK61USfe6wl/g1vDDmwz3mE75LsVAJjPYVQzceMSAKqSnS2eB1xSdrs8AGB+VbG7aBAAlYo2kiQGYWnriXNJK5b6fwqbiyhMsyxShg/uFUnWeO52/0/tt7/2sHhXs7+IBM8nW/DSr1QbHaJ+p874zmJGsNT3FC370YioSuaqwTBFMvh37qi95bwqxGUYCoTr6nahfiXdUO3PC3OHCH/gXFmisKx2Lq7X1DIZZRqbKr0gPdksLJqk1zRrB++KGq5KEUsLFdQq4BePxleQy9thGzujBp1kqb9s/9eWlNfDVTVtL1n8jujoK66EwgknN9m66xMuLGRmCclMZ9NwVmfP9jumD0jz+YYrIZC2EoRGyftmNhlZahwDwgtQ70FSxNr/r+bSgMcUPdplkwh6c+UZGJpFyaKvJQfHcm6wuShKbrccSai4e6BU43J/yvbAVH0+1wus
 e2e7300f4302b02412b0b734717697049494c4c 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmAZlogVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfalsQAJjgyWsRM1Dty8MYagJiC3lDqqeUkIkdMB569d0NKaiarwL/vxPS7nx+ELNw0stWKDhgTjZlgUvkjqZEZgR4C4mdAbZYO1gWVc03eOeHMJB46oEIXv27pZYkQZ1SwDfVDfoCKExGExRw/cfoALXX6PvB7B0Az35ZcStCIgHn0ltTeJDge1XUCs8+10x2pjYBZssQ8ZVRhP3WeVZovX5CglrHW+9Uo09dJIIW7lmIgK2LLT0nsgeRTfb0YX7BiDATVAJgUQxf6MD2Sxt/oaWejL3zICKV5Cs+MaNElhpCD1YoVOe2DpASk60IHPZCmaOyCZCyBL9Yn2xxO9oDTVXJidwyKcvjCOaz4X6c5jdkgm0TaKlqfbY8LiUsQet0zzbQT7g+8jHv31wkjnxOMkbvHZZGoQLZTjS9M5NeWkvW8FzO9QLpp/sFJRCsNzjEzJWZCiAPKv51/4j7tNWOZLsKbYmjjQn9MoYZOrsFz4zjHYxz7Wi46JHMNzsHwi5iVreKXp1UGTQYhRZnKKb7g6zS3w3nI1KrGPfEnMf/EqRycLJV9HEoQTGo4T36DBFO7Wvyp6xwsnPGBki78ib5kUWwwSJiBsyx956nblY4wZaC8TiCueVqu0OfHpR4TGNuIkzS7ODNNRpcH65KNulIMRfB4kMLkvBVA27lDhc+XnDevi5q
              d5d9177c0045d206db575bae6daa98e2cb2fe5bc 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmBHDE4VHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfo20P/2eaVVY+VgaHktRHpJKJsC8tc8brHXfwPTijTzWl/2d4rZ1QwvyYFycl8LwtHeVdjvbDf61YIX2BiucX+rG11x21LyPPgD90pQ0VdRgoGXgVZX27exkvS5DUhqXnVnbey5dH3pFAPtYsC3jHsoo8NyNDrn2nXdvzzABArljIVyjnG5JokPiEH3dQSY78HlJR451HlrWEmRgL9PlzHGDRmpkdypKiV8o58386uqCz5zfugA9aC/JYheNA40xM3PV24GbJ/dtMqztzOh6MVxFWV5+krK2hXBXk/p8eE1SYDoO5tqZAmSgKmBJZ5zas4zRBoJb51BiLM0cBaxmBiqZ+sv9IHknoyEMisc4+0O6z7JKqLiZetVbvNVOkCP/CbKyik+evbZnQB6JhgOSCjfcLD5ZFl8GiRiz84ZT3ges5RTyVcE6jJNUV+nwmNdW2qLQP9JydInKNwTrEgZcrJDv6i+lu519p8+zcOgIF1J+CO8qQaq3+j5MA4Dttat3anWOQNIzbx4yuG75NezVN3jnRGmoSGwg1YLseqjQCBlpJrBWTD1SsuWpgbKx4EiELDN+PcDovxB2pYa+NzFfv0ZFcnWuLpr6KjCgzBkTK5KfmTqu7I+eM29g+2JvmCao+kk8MVyVmV9H2f5xRvuhrEBmDNlLb7uOhJW3a7EvZG6g9EfW9
              f67b8946bb1b6cfa8328dbf8d6a9128b69ccdcb4 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAmB+71MQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91Vj+EADBa/tHfgyymKmXXl9DSlzwEhX1DkCE0aRcsbfXujnpOQrDi09pfHvtYEbgJfl6m8JEUOjuRRcxofnIWOC9UJCGC3ZfW5tTcHomCFlqjHhUxGKsvQ1Wcec1IH3mmzhqLnd0X57EgnNC6APwgxNVRmC0q7M7rSlNiE8BkHEUuyCau5FvpgdF31Aqa9IQP95pmmeDwL4ByPR1Nssu2/8N5vbcQm55gdjcggNjBvNEbaFHDS9NlGS8quvCMwRZkr3meDfTeCs9d2MveXXvV8GVOFq+WHMoURVijTjON+HuXB7HLegyhVOcigfbU5zxGY/IAJ/tAYEzBLWSYW6wjsN5uuZP267XhKpd2FT8Cfe9t3OnN1K21ndltlaMSdGyAynuepzVE0IELOCiKlgBZkdnft2XkUt2DDg/TqhOeXmUBzIFVze5KULSgrFvjkx71iV22LUGkIxzIuW5ieBMeZotKHzI+ZXO7xNSDIdoSfERKUqfYJKbksnBQLRxYUO77KetjocsMMYyB4Dpzu05+eWpYtZs2u5PsqP/Jv84Mz3QR0szAI1h3KlhmbkvKxnWnFYasAdFPMluX4G4X+9+MulODCwgw/RvQhh13M2QP0vGb1Xzu/JOuxRr3zuliTUfszd7YHVJoROzuT9PlcZ4criwZwv+fvbCN+F9LRbeI/BQBVZi6w==
 d2b62d716b095507effaa8d56f87cd27ba659ab 0 iQJEBAABCAAuFiEEK8zhT1xnJaouqK63ucncgkqlvdUFAmCAO3gQHHJhZkBkdXJpbjQyLmNvbQAKCRC5ydyCSqW91YvWD/4kn4nLsu6W6hpSmB6qZB7y9adX8mqwzpSfnt0hwesk5FiBmGnDWHT5IvGHRTq0B3+peG9NH5R0h1WgtCdyh6YxGg0CZwNoarv64U8llS+PTXp8YZo/bVex7QGKQJr45Xik4ZH6htJ0muJUhzpHa6wkthTxK2OuaTTJvJ53lY8dR4lmefxSYPAwWs/jOzkmPwIeK8EnG0ZcBtmheJESOzKnmmOF6N4GnUGFFz/W5q8Gfeqj9xKKDt+zdPHXCEZUYivBcMPL7UNti2kvrp3R7VXBzbw/bPAJTrq68M4Z9mFb0qRZ88ubGXu+LEufsG2Dls/ZF0GnBPeReuFFrg9jimQqo6Rf/+4vV+GtFBY71aofFDDex9/s0q7skNEBxLP6r/KfsachYzvdciRS46zLelrL/NhpDvM6mHOLWmuycCeYShYctGbc2zDK7vD136Da6xlWU5Qci/+6zTtAjaKqdIpJuIzBfKdhaakri8vlpplpNLIDMfTTLyYKVAuHUtZcwHcHWmx54b2ulAmNXtc5yB/JqRIUined+Z6KlYc7c7MKEo2FB2/0okIbx7bIiXbV2of4j3ufv+NPIQel1qsnX58vbYL1spdfynNMTHQ+TYc9lUvuq31znu2LLJ9ZhTOiLEt1QZB28lTukzNuH2MEpGWtrOBIC9AcXjyyZ8HlIwEWMA==
 f2c53fb24506c9e9fb4639871b13b19a85f8a 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmCQMXEVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfpJgP/isIDkbMuhot376RY2SwilSCkjJRoKRCDyLjJReBUF29t+DPWs8h971t2v5DIasfuQZthMv9A6DYcyEs1Q3NTKvT4TMKTTrqQfIe8UMmUa9PI1SIuTShiWbwonrN8rrVMVVcjPO/gookMV8/uoYW3wn/SThkBEYYauONBBVKbQ/Bt31/OPbEeAEdb/IEJ9X9PL1sfQkf+/DA/cwawS+xn01GAxWybx8eJkcJFdGdUcl/PYWgX76RSUhGvD6aHRJTZ1+sXy7+ligfpdPkNrQ248mVEEQkmZaCQ39dQPMX5zLa2hEX6eW9b1BEhNjHzbDfyqwc+F5czLw+R56vjPUyRCkxAZ6Q5Q3vkgLPBlZ2Ay0Lta/5+qGWcX+nDzfKfr2FhBLAnRZG/M+M2ckzR+8twyKg7/vdD8e/B3+Oxmu5QTS8xuj1628Brf9IehedQHoEPDe2M5ynhlEcybkbLz1R7zWKrh2h76OGQtspcjF997W1uZFx+DH6kHSznIm/8zEXy13R2nZk/0YtGX2UjZDv9bZ5X3B7T1673uscx3VpiT8YLJVKX7FyFLMgUbVY9ZGFlQ/pzUP3gTGa5rAB8b72U45jlXdKKvCn9B3hbS4j9OzJKpjsspWDmFHl2/a01ZOL/SZtMlm7FeYymUXKc10dndXlXTlGxHFUJQsii6t3dDyf
 dc27fd9fd076d6a031a08fcaace659afe2fe3 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmDnSgwVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOftvQP/j1mvheFHsv5TSJ2IEKgEK4G/cIxt+taoWpecEUVN5JAk7q4Y1xnzcoyqQdAyvZcTu7m4ESx865XW6Jvc0I2pG+uKcmO7ZfwrAOugoXXxrlXtopVfDDFZOLlk72x+Z5tQpL9QcBUgetkuOZLFhT+1ETjnFd2H4P4pwPjdTpn+YBmDmh1tWTMzllTDDzvZeE6iAjIpM9IQKL4jKxcEjPAX2XDa1xWhd/o9NZC9kYSTIBQvbFWAz3A0PSAudz0lu5YDXKJNtIHlzZtMFmcUlqJGM4MlD6v9tm8EQbCWTgOm0+wB5miDqv05aC6axD3LnSgrlPsmRDZCIRAws1JHEjKYFob7VRMxpivW7GDSd6QrmUbTHYN5eY0v1YB62dCa8W9qk2E7R5VdLRi4haFTv42u7jOZT0tSzRv/R0QppoVQ7/Fpqpps+aoZBM6EGj/pAxRgBTHeyI9WTFUAYDbhRuN9EoJAqRUCpXn39oR+TsaD9COENAJroX2WLIY8XFD3UzrpA9NPt7JE9mufWoNipNqLdLY7k3p3UxX0/SDboVlax6ORpQN+YzYhCesJaAOhlTAXMRMyXsfw/ScYttXxmIJ7BINYEMSXM55uiUPYFjE/GuZjbjgqk3dmJr7ceAyGa5v+m5Hr6efPSRHKUAxkEcDsXpcTHyEOVt3l7Qwfd+oUumK
              d7515d29761d5ada7d9c765f517db67db75dea9a 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmD4lQMVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfVsMP/19G6aZBokNRdErXcT86ahVy82IquR/CmLJcdj/4nehmBXToLCmdeqKe17ZKgZ7bnPnevhO07zPub7RUhDixnb7OxpbXiyP7x67FAqAfKvi8rZggmeWZT5kpiltoBIvHDlOlQhsgtfea0REULyn4zNB6dLED5zh2Ddr5LcWIjfOvIWo1F0eFMcRszL8f2u2ei2dERDuG8MSzMsiFHMAPRMHJjm+YukJBuz78CH4qT/Inkq52ao+3GCh4fFBhPG5+IABeCn1J4cAAK06mPcJqa7fbv7NfUCN9MeDNQUsUGGfIhKzGHJTb7PwXkKJ3qpLPs4FYGV1ZTucrIU1i65hXuf66QcYGlAQmKavS7xDOfZhzrZrAKe65dLpWdEH5mpTMcjaMBS+mhfMJT7DQg9T/9jISiKeqiFNkNOy1cobpJWes8iFwihEBtEhCtiVgnf7i7IzZY/spmSmP4ot/MEBi3jMjvAEaH1HyDGOPuBuqRSIRU+Mf5o1yB2kZmGL9vHWUzm/ySjQFYte061OyE9bZrbF9daOTdRip/CXPApOneVBIMwXc7fWDu45cKyVg7kYo8a0gcFfg39Ceja3Z8iJSFtJTuj1Sd9q8YU6pxqDrfPm1byJJlb7SvAoZfIGQPFk+DF6UVEcWRC0MYRm2bHXlaZwNVpgmFv6ZOVja3jxCJkw8
 d406b03607cdb8c06cb04c44efcc9a79d9a2 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmESg/wVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOf6kAP/1w3elvhAYQcK9hkEVCg4sQgnvcatOafCNaK0dVW9OOFbt+8DNUcHbtUHZtR6ETmSAMlWilIr/1vRMjy0Zic6afJ30oq8i+4f6DgLyTsLQL/QdwJQIwi2fZmHebv1PSrhT9tJAwtH6oG3cNhSq8KMme4l7sVR7ekB34Cmzk3fa5udMOuQG9xWbGTmeEsx0kYb+1oag+NnnZJqVTi68gGGxRW8TYZ1APXJcrZVfkldtaIWx6U1UdkWSTqWHV4fnnctp/1M+IgXCLT0iupY5LnxqGKQcMte7WKRPPdfhGF1ta+LN+QPHbwXhDRDIWPBVbDeHxjKcjz3h+DOeF0b7c5vKDADgo9LtHui9QhBJiCDHwsM+8gA+kNEDbtvIYYQ6CLxX9m1TttxI4ASIzFGIQF6nBr3mjQCzmOoWtgVh7R4dsQ9YZgm4twjsIg3g0MDhmgs71jn6Gp4BficF25nY8J6Ct8YopkPs2sfiBYJmyh9NJLDjwqNnjq3MBervPX3B+7p1dfIsK4JoSuop5A4lc4OOEhrwm5BKIxm30R4NtB15RZ7nI0DcRFcwNQiTYPG+nOaPsFzeZD6lj8+YnuLyo2aCnf4K26/1YTlE1wOFkCb1reL99++i8FP94poHBKZ7+6HT6gk4Mmnfb52II4yWlh/CYLeKEzFFfAiOTvfhzpIvqg
              53221078e0de65d1a821ce5311dec45a7a978301 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmEeqLUVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfMb4P/R4oPBjSKrlGbuxYClNdP0lV4C1NUU1SPa+Il4QwGQteKD+RDfvp8z8+c45rVIEGiUNzaSJP/ZEyhBVW657rYzIhBnZgqnpwBzOViqe4Q3lHiq6wPKjEDIRJafcqMb6MaViPS6iRn6hhMlAcPcoabwhXrUgv8QyxVSTFlJm0RGbUVekQLIWKEAnwcWLHKt0d2DrB0/706xXtKxdJ8N/2WCVOOkr7UvpdLXo3quOz1S930/o1iF/csggsi9q4oZYj2XBdBGHayoqkhKAQMyBfXH19RqW3SWZafY8whrZDCz+9AAmJJk8hjQl6xrT/ZVweRfqvRoMJBgjQdFTi58wjC8995ZXKEC7jsJCEblyRJkc23opuAArPEkJXLDR+oK1vOfikaRjmQoMPAMDjbxTUyVOuHcX+PxMtq9NAO0MKcnSr+D2Xc28TGY9PkBhRkEnN3nlZH5z7DvF8GfOnUt5SGhFiQHhXnL6jDBCQVDKAoCJn0WKDG9+29I6st2eGEwKaIjZQ9NCtaLASiauopMOyWWbHeM58bCl80TBXuj+3W+mo+zDSLoGwWJc5oFdFpmnGGTQtkxPDiV4ksIgJAMb/KHkGY+RxnEsWgX1VcR2c1sYD4nzOjrt4RuvX1i+cfzRjLOchPiru7BbrBQRTXGhrvNzsS9laTCxCH2oDazIudia4
 a60679cf619e14cee9442f865fcf31b142cb9f 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmEtHx4VHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfALUP/331tj8MaD6Ld0Jq+yLK7dRlLa0iZ6Kbq2Nq2bYFrv1V99RMG/0xipxWnHfn+B0qdane15tgYIugiVl5pQCGRBeva5CJEg5hfiN53tDDXc2duwaj+kYAREPZJm3lEtv4Tp87E8XZxnJ5qDnNeLCmtpFEEs2bgOHHY/fwHUf/hu0jHJHvkxXh8zPHBf2le6UOMR65PS89bv0jKKmtYPVuYhs/sPRFp78FbYZPiJ0x5NxQsrkYd3ViaQaT2Hb47fpTEg/t1yD3nkZyxHzrGhkFwrLJDMTafuPaXtzVN0BPT9iztgONm+5cF4g6+4AvFWvi5ki87UmrYMCHoiBxKycKR6O+rxh5aay/69I5iIJlcrxyZ/YkzaTUbw4rAZdaTfODwaYOBeMPJp/MviNB5kEGeCV3yLpbftIzsO9BPJ4VtSadVA4HPN/OvAGcYvGO58rN22ojHnqyrnmmuhc4K2/i94+dkMbTyKHrROMXwkJFgH4i3nukyo5fYw5c5ggYAvtEsHLpihv9hXPafTQvmz17f+7/fNi6qJsjEhH8MPjfFpydkjptIyszZ9tx6HyE+2699vJGVHRVepw6RFVOuneXsyKzNeSaw/LmO7B+PfBxpBTvWLblD6DH09pzisTacoMrhvugvfGZsYEFxGt34NvN3Hqj0+ongzFM53UvzMy2fLm5
 b18aaaddd654756be40dec59d90f2643be 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmFcc4wVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfatIP+wXnpFitqScNjqnBK6+DaTj+rmBlKoZGB1IQJW5ziDN59gJmT/axemrc3O8BJ/OFO+gDFTX6mk1/L+1Ul4BAF8Yo8XrPd/V7+M02ZUgKTbHmOqTosa9sLeSEojdQQRfSPTHgtA3CLm6VB91fCCfpS9yfCWO3+T8owNelHl8beSqcSlmAzPjqeF1EmalBO4YjSeOCfSdNpVvUGYG8OL/LwYWJqbea7LpN/Sq0piNMqYbc9GYeB9tnf0338WlGEaLTTDk8V3iES+EZxTNeN8NnpGvU0RN50CUfFVyadtbdXUzRDjF4mpdEnsQBkje3hGotyrzDZs1IjKGCANiNBb6dyn/wgv4APOLFw/BLat1Y7z2ZJ6sqUkBbfOs6H2KfufwFZl1sggG1NNXYrwjdS8dHuwi7FRzWMgcYi8Rle8qX8xK/3+We1rwbHfYxhmlEvC8VEC9PZl/K13aIuKmCQ36Es8C/qAtnNfSKZNkYoi/ueAvGFvJo2win1/wIa/6GvBfCxS3ExR1dH+tAUHj2HgMuQXMI6p9OuEloI/mJbdLmU9vnn06EcIyiIPd3dn4H2k0h2WNzyIoVE6YjD5T86jumrUxIj6hp+C9XYYkoj4KR17Pk7U4i3GixDpupLc/KoxiQRGSQTogPjD5O5RCg41tFaGav/TcyW/pb9gTI+v3ALjbZ
 ee0244fc1cf889ae543d2ce0ec45201ae0be6e1 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmF4AWgVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfxu8P/R8FftAoLkFGHnrzXA9Wa+ch+wunUNixCSimuXjG5sUtDSDlNT+xGj0deTVRVDylFd5HShR6a8NV+2P9edgJYDOKE70j4DJxHdeDyZ3l09YEBymrluE4FygXwpG0B3Ew9pUD85yFxa6UfIFWvNTGYi7XCHBl85buCkMACafN97802jXuE3JV53FvW6Fp917hM0saG48Cnp33WZxdUrZdxXU0Q8bZ9OBYCuGq8Wt2ZIqfEM6YXmvOzlkZf6oJb65rYOw2KgfLs/5nEGiDUNK2akuEhAZLi7uL0dt4WzYAbLyRhIpMpFPitk9P+Ges7iYINwSyZKZcsNPm0NiJupSjKqIYuuLte9HR59RkDFGgM9hbFnskElgHXMqLxi+RqjDVrj2efbuyWzDCn6eVZyn7vmxy9/oLM9vnVsvvdziN2uNUPL4CVmnOZciCdkEZQtWynyyEGzNyq7kPH593ct3tYMxpzs3wa3o+sSdph3lf7caXskij0d0woRZneuZFwp26Ha9tKMMRmXzgFvipzL+o2ANWV6X2udO0pXmKhzYJSBcUPlmVz8hyJaV2D3nmXeFHKVrPa/CqnSGNPWNQC39im1NyPKbfJAA9DZmw7FKg/b23tJq8w9WkBAghEUhC4e54Eb068awt/RDaD6oBYfpdCnQ1pbC/6PHnRSOm8PubGoOZ
              a44bb185f6bdbecc754996d8386722e2f0123b0a 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmGKo4sVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOffmQP/jsOxxP0F9TliKYp7YjgMagtnebk+qdbq9pX8y8GdjGirRwCy/rMm3pXMNQDiWd3ZdYLICZIz8aSYbPL6HD78O6F68IWOVG5AwLM6knUNcEzmrPoFnSU1J7jaz8ERFmfNV6loes3oYj/VhRUDiFEmG1sflCc1iXvTEXaOi2PObo7iORR/2JtOlMQI7bASBTo0F7QTRzOuh+SzgJ6ItqpvjC+I2Iidn8yZ/F3jZXZ24on/D+b2nLQ5b7yc7pzVNyqiTFF6xHQEtRjNRv+hLS9mdD/oI6Vhwmfv7GD8U4MyudDfz5GEv2AE9cwOKRONfHdXhFX3UiubaDmDlo+mE3xXIPYJoTtadoUhVItCe5YAlp9P6uEAaWk/Z1zI+9ydYACycO0RySrphRJ3DmDITs7D2bQEsK/YB1NBzwlUJVFiTu8x2+taBk3vO66cfuyubvPXpdZs6VcnIxSMfduP29zYLj7L1YZo58y3qhKeWcZexYSBT/dtGZlOOdobI/t9YHKnrUtzUCL9JIuxqn06+dSU9DlNuOd19Mdr2wu+xncuzlkd+Y4DavctrA0uSw4CAID6e5UIoknAeOzMSFySZ+JLw79z1LpFx/t3wof5ySC6olLO1NFesK89NAYszIjeTOQnpcK9sA2OaANTDbC7sX12OmpPlRySNcNRsaNgux6Bnl4
 d08b289e2e526259d7d5ea32b70fe76d5b327d7 0 iQJJBAABCgAzFiEEgY2HzRrBgMOUyG5jOjPeRg2ew58FAmGcvOQVHDc4OTVwdWxraXRAZ21haWwuY29tAAoJEDoz3kYNnsOfNcAP/0zjJ+vfms7hBPltQJxzRX3JaMSDGyFB6+0CXJnEHClcjmcmmFq7yPYSZhO1/wRwNDag1A+xOr+xch0VHy3s2L4JDVqpTEIGDVX9MZxqDYdFMpMmx63KQeOraTbd8MCpbsiCsp+yQWwQ0k8sjajY2FhpJFezcD8EVH+XQJSkBsPGQZGezNt6IVlnsnBpTl6abVFWrsHhpos1Wa7iJM/sS91dy9We5H3B1eEn8KOMyj3eWEA6D8D29kCS66E8+AQ+f9ctresD2g/6xS1P4CTgvqacS+gj04rMUKmmQUoMzAXlS4wO2F6J0mWdKfZsv/urfJx7oc5GZysrXw+T/YLxFKuxls1uCq6mTBxbf/aJ91G4m0UT/fczNrQaDDhPIFEZVktd18NphUOebTGxDiCW/mk9IOXxEI7bprlBdBBM3dkCAg+O0h8kdN007jjoLIiTw7K+XZ1A41zqGqXMQ2R/0xTltX9NXAe9xNhAEQhwSCH2TsB5IKI6+EHE6ZaNsyuwvlPhaQXfmOU22JBlUGE9IdEU5whd9760xJYTx3WEnbuED0UltAt3vgyvq+li1/Z7HDuzUyNha8YsaPw2QeHFUFwzxqoxo501/eDs9bXjBt7E4vsYVQC51sb3uS9kRbBB9GOiyx/HICZcbEQjy5TxVW5Bp0uD6Fu3nRytL0DDDIDF
 fdf4cca80cb9ae40537a90995e6bd163ebc0b 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmHVzPMZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVmiyC/48p6+/JJi8WaY+Xdxh1IMK1/CB3dYcC99+V89asIW+g/X/0FacTSSAGkvDrjNSeYAkXGp3g/LbEbwoZhKxF8MyKU7TOn62lz8JETwebtjxehjVfPUy73RJbuLPDvn9m16YHxuC848hDZHnqk/PjaBVHeZ2cN8T7F9VgXkhyYStV9GT2PSQUsvkQAxjiLilyKs3RaZAduZPvOmGaq2CfK91PbScKaKgYShkKym7gfhU1o4pynNmuPqRwUJyihaZqsKDjOn8OHeJpqAm7ODmR+SIOvMvFbbfS8mTSfYMHsP+r+JgbqSVNG99qEqsIW3HznGe/OpG/1QS3MVVSyi87oHR1UcN91vKIiln92i+7Ct7GttjkgkkqfQEw1oAELCmiHacYEBbLvQGaXdHROeO6wqXUKvI4KeM3CPt2qsouPiKBzSF1eOPd967NNvgTgcabT2ob0YaXmWdZasJnZ74H/3FMMC98WhYe3ja+6cpl67PZlNUWlnIZBlyL63DWSJ09us=
              75676122c2bf7594ac732b7388db4c74c648b365 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmH6qwUZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVogkC/4hgjtCXykyst2XuC93IkWdRoXiFn2+C/r/eX25el//+Og5T0KZmttFGrmTCSCdb/ZkjPg1ZHYBUK9gyQCOXoimATIeql/USCcglpVBRMTaaqvpJyHA1antI0HIsNFGjDTIxHsJXgghMEv7qVR33ItpZ8gtWbJJLewOwi2UHtLcmif77SgpeADh/E/PuQT+0Wd5gA6jk9Fml7VBP/nU81j25ZyxB6p8oUv4gFSNDZtrnA97mQ35jYZZITl8e80Y9Z/8KJFcRk29kxIudOikwn6AD7ZW/H85a3lDOtTMhgBDNlMxvXx6eviKfsrIVtNCm6QDF+36VstTR+idWyhnkq8g20NXcgWt79/CTWT7ssFmzdsHhdhWfJF99I0R0FCG0DSV313UmleZawavG1btOh4qCjTAWF5gnvsHfEIV1SAnDeeD6T27c8yIW7au9QXlkZds0xmFWLqkl6TxKpl7oa/bGDArAvOA3zHAeMlwXQKhhthjR7fU9PQnWsFXCt43GVo=
              dcec16e799ddb6d33fcd11b04af530250a417a58 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmIPiSsZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVvRYC/9Ul8I7vJvCaFwotgAuVBGbpcyYwhCkxBuxyROInUjhQdrSqYLUo7frlDEdoos1q0y2w9DiTyBeqeewiYw77DXQzKPtxqJDO3m1exnbtsmUQhQBF8mUyDqO0yay6WcGp9daqIlFnf8HzXxBgvkpI1eReVoLBvGWzc+MWKmdPrVsY8CLyMCSXKQldyEa9uAARBRDnT2HTnPUDwS3lav5sHYhwWUuC/dwSQWlSsmIUrY2sB3yY9KS2CrUFkXGo3tmQNHayCXfKmyW04xoYlIKQxrXLQ5hOCaogExsSkdXzCDaQS6avS0U8QaM/XuXe2BDR4wq7w7iomM7xagoqbx/0VINizfbSh2sA/Nxt4/mf9V2VCPUh9QlSJztNTbSUOvpOPbk9l9KafgEQTspnsleRXQymAhBuCd9aap0Q9NC4vixVPWxjqyxyFS0eRbnZ9/LTI0+ZCHTizupG0nUiXY3cpwQB6a7CRdn8qdMsA0FURAJlVE4nDlSsY4v9AWxPHreGJw=
              c00d3ce4e94bb0ee8d809e25e1dcb2a5fab84e2c 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmIPn9oZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVpamDACfmZw0FscQ6oCs1ZyWZ2sf6xxYnk242h4ca8fyILrGfuhlgkochlMwF8id3EPVKnie3QHBi33Nf5Tz9eFTFR4z/eQ5W8R+bjYWo/F+4FDkaTIprvg4gfoH1MklmpVhPa7MFVmp7tmSx/0EVdpJuMkJSeAU1kQ6Mq8ekMWQT4vtLbkAOGZcnwKiU57j8cYnOjoIqA+22/S0DBWMKjEnuz3k8TjplsZXVgTEUelFAwT4SC3qNSIBvVYyDmdAoD0C4zL88tErY0MeQ/ehId6E1khLvw9I65z/f2hOxXiDdk0b6WV2MCh1rxCX5RUiH0aNUmG+hGphpH0VVqQihkQEIdzZhXiFVlEc/rAbdt3g7pVc2RuWSanBUEOcvly0r40A2wRCka1jjgfz7dtmjZ91SKCPpOUdxHfaqqWz/0Y/oIgpq/UM+1fufDxeLZG+OY8B5y+c+ZUuGacAVNRQku6IB+0dT4/DTEsYWT3VMIH0ZzGFiAQ2g3IPo6qlLFK54LztXTg=
              d4486810a1795fba9521449b8885ced034f3a6dd 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmIePhwZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVm3LC/wP9h6bFiy1l3fJhmq2yKuXu/oNWqT7CmOPqOPnQoO6Pd7a184kvgrabU9dsnXllj1mtbUhaIcfZ8XAb30lTbr0W1dSDoT0QWMY7sOFgXIvJSbWWmFo8DrYQSTlg1xA0LWdwsSKmce/r1G6D7JERj5VzBs3Hq65Kb9vg94vqdVSvyye+YzSODSh1w8P0qsgv78UWqabSrf28DlUp/kG7j43k1J93ZEOgH7+jrxgiQ2WzhmhlWcUFJOGxchbdDl5XZptwPssNstUgXfZKe5sFOI7WJSN//rHo3JgLbEDCX7TMe82aPl2DxEquHNH8rrOha4UuGZjFwO+/PzykItUCPzPWabE6z49w6+/G1us+ofts1z8Muh0ICegFxbd0bRotGRmJ/iEZqrtgFQokx1SSlZKArbRBbLfWoJcczxWxBK1qCz2avKY4qKcieC9TTo7LrHqA5JvLNuqvInKITYOfq1zCuLvxnaSCQTKKOEEb9/ortjxN9rvx1bFyRorVvXR+J0=
 bd6bcd31dd1ebb63b8914b00064f96297267af7 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmJMXf0ZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVpSlC/sHnQTin4bLp+F6keT9gGCoDqx11cf4Npl6RmqM3V4SN3hP3k8gwo5JOMWNSYzwxuBuzJ24EBTtgV139NPdeHce3LEaDMMg+n5YlQjl3vqFnYPAkX973yHH1R1ijkdGNtM4KfWw6C7b8stNaKCQmnRBsKy7oxGKvHoL8ufiSmxVtkP8ImW3x9oiYUEueIWMVhaIvNANxOzsiU++yubo1ldFGXOnNAS91MALeeu7ikClaJQQLp6jMobnn0qI8TGzbe5LnexA81/qIltgFLyUAWA2d3NXVis7hFjwLToyBkObpZfq6X/7a9XhBHMwTM+O8ViYODraupcYw0vrqT93cbuBSN106sC1UERaVN2YNb1gsoyqXTZ2F8ho5QZWJphQw9cwKJkOn81SXJ8ZWr+L8WVm78mrbDV8zT6lQ/7IsmIXTQNWMBgeGc74qyReowyswP7hSbl9iQDcdKMus/4Gm9cqTnYg3Bt8jZ3lupeYMv9ZSFmKDG8A69QFLKYKzd/FFx0=
 ddd5e1f5f67438af85d12e4ce6c39021dde9916 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmJyo/kZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVsTVDACmg+uABE36kJcVJewoVK2I2JAdrO2llq3QbvzNb0eRL7bGy5UKJvF7fy/1FfayZT9/YTc6kGcRIeG+jUUiGRxMr0fOP9RixG78OyV14MmN1vkNTfMbk6BBrkYRbJJioLyk9qsXU6HbfRUdaCkOqwOKXKHm/4lzG/JFvL4JL6v++idx8W/7sADKILNy2DtP22YaRMgz38iM3ejgZghw7ie607C6lYq4wMs39jTZdZ3s6XoN+VgsLJWsI1LFnIADU5Zry8EAFERsvphiM2zG8lkrbPjpvwtidBz999TYnnGLvTMZA5ubspQRERc/eNDRbKdA55cCWNg3DhTancOiu3bQXdYCjF1MCN9g5Q11zbEzdwrbrY0NF7AUq1VW4kGFgChIJ0IuTQ/YETbcbih2Xs4nkAGt64YPtHzmOffF1a2/SUzH3AwgMmhBQBqxa02YTqyKJDHHqgTyFrZIkH/jb+rdfIskaOZZo6JcGUoacFOUhFfhSxxB1kN2HEHvEAQPMkc=
 b10151b962108f65bfa12b3918b1021ca334f73 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmKYxvUZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVqsDC/9EKBjkHvQeY55bqhqqyf5Mccw8cXH5/WBsyJYtEl+W6ykFRlTUUukY0MKzc1xCGG4sryTwqf8qxW92Yqt4bwoFIKIEpOa6CGsf18Ir/fMVNaOmYABtbbLqFgkuarNLz5wIMkGXugqZ4RUhs7HvL0Rsgb24mWpS5temzb2f0URP5uKFCY4MMC+oBFHKFfkn9MwAVIkX+iAakDR4x6dbSPKPNRwRqILKSnGosDZ+dnvvjJTbqZdLowU5OBXdUoa57j9xxcSzCme0hQ0VNuPcn4DQ/N2yZrCsJvvv3soE94jMkhbnfLZ3/EulQAVZZs9Hjur4w/Hk9g8+YK5lIvJDUSX3cBRiYKuGojxDMnXP5f1hW4YdDVCFhnwczeG7Q20fybjwWvB+QgYUkHzGbdCYSHCWE7f/HhTivEPSudYP4SdMnEdWNx2Rqvs+QsgFAEiIgc6lhupyZwyfIdhgxPJ/BAsjUDJnFR0dj86yVoWjoQfkEyf6toK3OjrHNLPEPfWX4Ac=
 cc5f74ff7f0f4ac2427096bddbe102dbc2453ae 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmKrK5wZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVvSmC/93B3If9OY0eqbzScqY4S6XgtC1mR3tkQirYaUujCrrt75P8jlFABn1UdrOgXwjHhm+eVxxvlg/JoexSfro89j8UFFqlVzxvDXipVFFGj/n8AeRctkNiaLpDT8ejDQic7ED566gLSeAWlZ6TA14c4+O6SC1vQxr5BCEiQjBVM7bc91O4GB/VTf/31teCtdmjScv0wsISKMJdVBIOcjOaDM1dzSlWE2wNzK551hHr7D3T5v78NJ7+5NbgqzOScRpFxzO8ndDa9YCqVdpixOVbCt1PruxUc9gYjbHbCUnm+3iZ+MnGtSZdyM7XC6BLhg3IGBinzCxff3+K/1p0VR3pr53TGXdQLfkpkRiWVQlWxQUl2MFbGhpFtvqNACMKJrL/tyTFjC+2GWBTetju8OWeqpVKWmLroL6RZaotMQzNG3sRnNwDrVL9VufT1abP9LQm71Rj1c1SsvRNaFhgBannTnaQoz6UQXvM0Rr1foUESJudU5rKr4kiJdSGMqIAsH15z8=
 de6f5d724bba7bf1669e2838f196962bb7528 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmKrVSEZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVqfUDACWYt2x2yNeb3SgCQsMhntFoKgwZ/CKFpiaz8W6jYij4mnwwWNAcflJAG3NJPK1I4RJrQky+omTmoc7dTAxfbjds7kA8AsXrVIFyP7HV5OKLEACWEAlCrtBLoj+gSYwO+yHQD7CnWqcMqYocHzsfVIr6qT9QQMlixP4lCiKh8ZrwPRGameONVfDBdL+tzw/WnkA5bVeRIlGpHoPe1y7xjP1kfj0a39aDezOcNqzxnzCuhpi+AC1xOpGi9ZqYhF6CmcDVRW6m7NEonbWasYpefpxtVa1xVreI1OIeBO30l7OsPI4DNn+dUpA4tA2VvvU+4RMsHPeT5R2VadXjF3xoH1LSdxv5fSKmRDr98GSwC5MzvTgMzskfMJ3n4Z7jhfPUz4YW4DBr71H27b1Mfdnl2cwXyT/0fD9peBWXe4ZBJ6VegPBUOjuIu0lUyfk7Zj9zb6l1AZC536Q1KolJPswQm9VyrX9Mtk70s0e1Fp3q1oohZVxdLPQvpR4empP0WMdPgg=
 a5fa3cf52f936e0de3f1e507c818bee5ece6b 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmLL1jYZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVn4gC/9Ls9JQEQrJPVfqp9+VicJIUUww/aKYWedlQJOlv4oEQJzYQQU9WfJq2d9OAuX2+cXCo7BC+NdjhjKjv7n0+gK0HuhfYYUoXiJvcfa4GSeEyxxnDf55lBCDxURstVrExU7c5OKiG+dPcsTPdvRdkpeAT/4gaewZ1cR0yZILNjpUeSWzQ7zhheXqfooyVkubdZY60XCNo9cSosOl1beNdNB/K5OkCNcYOa2AbiBY8XszQTCc+OU8tj7Ti8LGLZTW2vGD1QdVmqEPhtSQzRvcjbcRPoqXy/4duhN5V6QQ/O57hEF/6m3lXbCzNUDTqBw14Q3+WyLBR8npVwG7LXTCPuTtgv8Pk1ZBqY1UPf67xQu7WZN3EGWc9yuRKGkdetjZ09PJL7dcxctBkje3kQKmv7sdtCEo2DTugw38WN4beQA2hBKgqdUQVjfL+BbD48V+RnTdB4N0Hp7gw0gQdYsI14ZNe5wWhw98COi443dlVgKFl4jriVNM8aS1TQVOy15xyxA=
              f69bffd00abe3a1b94d1032eb2c92e611d16a192 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmLifPsZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVukEC/oCa6AzaJlWh6G45Ap7BCWyB3EDWmcep07W8zRTfHQuuXslNFxRfj8O1DLVP05nDa1Uo2u1nkDxTH+x1fX0q4G8U/yLzCNsiBkCWSeEM8IeolarzzzvFe9Zk+UoRoRlc+vKAjxChtYTEnggQXjLdK+EdbXfEz2kJwdYlGX3lLr0Q2BKnBjSUvFe1Ma/1wxEjZIhDr6t7o8I/49QmPjK7RCYW1WBv77gnml0Oo8cxjDUR9cjqfeKtXKbMJiCsoXCS0hx3vJkBOzcs4ONEIw934is38qPNBBsaUjMrrqm0Mxs6yFricYqGVpmtNijsSRsfS7ZgNfaGaC2Bnu1E7P0A+AzPMPf/BP4uW9ixMbP1hNdr/6N41n19lkdjyQXVWGhB8RM+muf3jc6ZVvgZPMlxvFiz4/rP9nVOdrB96ssFZ9V2Ca/j2tU40AOgjI6sYsAR8pSSgmIdqe+DZQISHTT8D+4uVbtwYD49VklBcxudlbd3dAc5z9rVI3upsyByfRMROc=
              b5c8524827d20fe2e0ca8fb1234a0fe35a1a36c7 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmMQxRoZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVm2gC/9HikIaOE49euIoLj6ctYsJY9PSQK4Acw7BXvdsTVMmW27o87NxH75bGBbmPQ57X1iuKLCQ1RoU3p2Eh1gPbkIsouWO3enBIfsFmkPtWQz28zpCrI9CUXg2ug4PGFPN9XyxNmhJ7vJ4Cst2tRxz9PBKUBO2EXJN1UKIdMvurIeT2sQrDQf1ePc85QkXx79231wZyF98smnV7UYU9ZPFnAzfcuRzdFn7UmH3KKxHTZQ6wAevj/fJXf5NdTlqbeNmq/t75/nGKXSFPWtRGfFs8JHGkkLgBiTJVsHYSqcnKNdVldIFUoJP4c2/SPyoBkqNvoIrr73XRo8tdDF1iY4ddmhHMSmKgSRqLnIEgew3Apa/IwPdolg+lMsOtcjgz4CB9agJ+O0+rdZd2ZUBNMN0nBSUh+lrkMjat8TJAlvut9h/6HAe4Dz8WheoWol8f8t1jLOJvbdvsMYi+Hf9CZjp7PlHT9y/TnDarcw2YIrf6Bv+Fm14ZDelu9VlF2zR1X8cofY=
              dbdee8ac3e3fcdda1fa55b90c0a235125b7f8e6f 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmM77dQZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZViOTC/sEPicecV3h3v47VAIUigyKNWpcJ+epbRRaH6gqHTkexvULOPL6nJrdfBHkNry1KRtOcjaxQvtWZM+TRCfqsE++Q3ZYakRpWKontb/8xQSbmENvbnElLh6k0STxN/JVc480us7viDG5pHS9DLsgbkHmdCv5KdmSE0hphRrWX+5X7RTqpAfCgdwTkacB5Geu9QfRnuYjz6lvqbs5ITKtBGUYbg3hKzw2894FHtMqV6qa5rk1ZMmVDbQfKQaMVG41UWNoN7bLESi69EmF4q5jsXdIbuBy0KtNXmB+gdAaHN03B5xtc+IsQZOTHEUNlMgov3yEVTcA6fSG9/Z+CMsdCbyQxqkwakbwWS1L2WcAsrkHyafvbNdR2FU34iYRWOck8IUg2Ffv7UFrHabJDy+nY7vcTLb0f7lV4jLXMWEt1hvXWMYek6Y4jtWahg6fjmAdD3Uf4BMfsTdnQKPvJpWXx303jnST3xvFvuqbbbDlhLfAB9M6kxVntvCVkMlMpe39+gM=
              a3356ab610fc50000cf0ba55c424a4d96da11db7 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmNWr44ZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVjalC/9ddIeZ1qc3ykUZb+vKw+rZ6WS0rnDgrfFYBQFooK106lB+IC2PlghXSrY2hXn/7Dk95bK90S9AO4TFidDPiRYuBYdXR+G+CzmYFtCQzGBgGyrWgpUYsZUeA3VNqZ+Zbwn/vRNiFVNDsrFudjE6xEwaYdepmoXJsv3NdgZME7T0ZcDIujIa7ihiXvGFPVzMyF/VZg4QvdmerC4pvkeKC3KRNjhBkMQbf0GtQ4kpgMFBj5bmgXbq9rftL5yYy+rDiRQ0qzpOMHbdxvSZjPhK/do5M3rt2cjPxtF+7R3AHxQ6plOf0G89BONYebopY92OIyA3Qg9d/zIKDmibhgyxj4G9YU3+38gPEpsNeEw0fkyxhQbCY3QpNX4JGFaxq5GVCUywvVIuqoiOcQeXlTDN70zhAQHUx0rcGe1Lc6I+rT6Y2lNjJIdiCiMAWIl0D+4SVrLqdMYdSMXcBajTxOudb9KZnu03zNMXuLb8FFk1lFzkY7AcWA++d02f15P3sVZsDXE=
 f1dba53c961dfdb875c8469adc96fa999cfbed 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmNyC5sZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVqF+C/4uLaV/4nizZkWD3PjU1WyFYDg4bWDFOHb+PWuQ/3uoHXu1/EaYRnqmcDyOSJ99aXZBQ78rm9xhjxdmbklZ4ll1EGkqfTiYH+ld+rqE8iaqlc/DVy7pFXaenYwxletzO1OezzwF4XDLi6hcqzY9CXA3NM40vf6W4Rs5bEIi4eSbgJSNB1ll6ZzjvkU5bWTUoxSH+fxIJUuo27El2etdlKFQkS3/oTzWHejpVn6SQ1KyojTHMQBDRK4rqJBISp3gTf4TEezb0q0HTutJYDFdQNIRqx7V1Ao4Ei+YNbenJzcWJOA/2uk4V0AvZ4tnjgAzBYKwvIL1HfoQ0OmILeXjlVzV7Xu0G57lavum0sKkz/KZLKyYhKQHjYQLE7YMSM2y6/UEoFNN577vB47CHUq446PSMb8dGs2rmj66rj4iz5ml0yX+V9O2PpmIKoPAu1Y5/6zB9rCL76MRx182IW2m3rm4lsTfXPBPtea/OFt6ylxqCJRxaA0pht4FiAOvicPKXh4=
              c890d8b8bc59b18e5febf60caada629df5356ee2 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmN48sEZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVqwwC/9GkaE5adkLaJBZeRqfLL710ZPMAttiPhLAYl9YcUeUjw2rTU1bxxUks0oSfW4J0AaJLscl+pG4zZW8FN2MXY3njdcpAA/bv4nb+rq50Mdm0mD3iLOyKbIDQbUoYe7YpIPbpyuf8G/y4R1IXiLJjK329vzIsHkqyKPwUzxvyfZkjg6Lx00RRcfWrosb2Jb0+EhP9Yi7tjJmNWjsaTb8Ufp+ImYAL3qcDErkqb6wJCGAM0AwVfAJ7MZz3v3E56n1HTPhNqf8UvfR4URsuDlk56mP4do/QThC7dANiKeWrFJSBPu8uSpaHzUk1XCat0RHK03DMr15Ln1YCEhTmaedHr2rtp0fgGqaMH1jLZt0+9fiPaaYjck7Y+aagdc3bt1VhqtClbCJz5KWynpCLrn8MX40QmXuwly+KHzMuPQ6i0ui95ifgtrW7/Zd7uI7mYZ2zUeFUZPnL9XmGpFI595N8TjoPuFeO/ea4OQbLUY+lmmgZQrWoTpc5LDUyFXSFzJS2bU=
 b13a3ae0e29a5d4f485393e516cfbb057d0 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmO1XgoZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVn8nDACU04KbPloLl+if6DQYreESnF9LU8C+qnLC/j5RRuaFNh/ec6C3DzLWqWdmnWA/siV3nUR1bXHfTui95azxJfYvWoXH2R2yam+YhE256B4rDDYWS1LI9kNNM+A33xcPS2HxVowkByhjB5FPKR6I90dX42BYJpTS5s/VPx63wXLznjFWuD7XJ3P0VI7D72j/+6EQCmHaAUEE5bO00Ob2JxmzJlaP+02fYc814PAONE2/ocfR0aExAVS3VA+SJGXnXTVpoaHr7NJKC2sBLFsdnhIRwtCf3rtGEvIJ5v2U2xx0ZEz/mimtGzW5ovkthobV4mojk0DRz7xBtA96pOGSRTD8QndIsdMCUipo8zZ/AGAMByCtsQOX7OYhR6gp+I6+iPh8fTR5oCbkO7cizDDQtXcrR5OT/BDH9xkAF1ghNL8o23a09/wfZ9NPg5zrh/4T/dFfoe2COlkAJJ1ttDPYyQkCfMsoWm3OXk6xJ3ExVbwkZzUDQSzsxGS+oxbFDWJZ64Q=
              8830004967ad865ead89c28a410405a6e71e0796 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmQAsOQZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVl7XC/0W+Wd4gzMUbaot+NVIZTpubNw3KHBDXrlMgwQgCDg7qcqJnVuT1NNEy5sRELjZOO0867k+pBchZaxdmAiFwY1W76+7nwiLBqfCkYgYY0iQe48JHTq9kCgohvx9PSEVbUsScmqAQImd5KzErjhsLj8D2FiFIrcMyqsCBq4ZPs0Ey7lVKu6q3z5eDjlrxUIr0up6yKvgBxhY0GxyTp6DGoinzlFMEadiJlsvlwO4C6UpzKiCGMeKNT5xHK/Hx3ChrOH2Yuu1fHaPLJ+ZpXjR33ileVYlkQrh1D6fWHXcP7ZuwsEKREtgsw1YjYczGFwmhBO362bNi5wy33mBtCvcIAqpsI0rMrExs66qqbfyG+Yp1dvkgzUfdhbYFHA+mvg3/YTSD9dLKzzsb69LM87+dvcLqhBJ0nEAuBmAzU5ECkoArbiwMT96NhhjLPRmJJdHNo0IDos/LBGTgkOZ6iqIx8Xm/tgjBjFJG8B+IVy3laNgun4AZ9Ejc3ahIfhJUIo2j8o=
 de4896508e8ec387b33eb30d8aab78d1c8e9e4 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmQBI2AZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVrRZC/wJyPOJoxpjEJZaRoBmWtkOlf0Y0TyEb6wd8tZIVALNDYZMSMqT7UBjFmaZijOYndUW7ZCj1hKShaIw80vY/hjJ3KZMODY9t91SOwmrVaGrCUeF1tXkuhEgwxfkekPWLxYYc688gLb6oc3FBm//lucNGrOWBXw6yhm1dUcndHXXpafjJslKAHwJN7vI5q69SxvS6SlJUzh/RFWYLnbZ2Qi35ixkU12FZiYVzxDl2i7XbhVoT5mit6VTU7Wh4BMSYuorAv937sF9Y6asE7sQUYHC2C2qjp8S5uFXV/IrhCPbJyWVc4ymPm58Eh6SmItC9zHDviFF9aFoZMK/lfK3Dqumu3T9x6ZYcxulpjNsM0/yv9OiiWbw33PnNb74A9uwrxZHB3XexXiigBUlUzO4lJQ5Oe1rhpPfPPRVyxaeZ8/cPmoJjCuwoiG0YtUeNH5PkHi05O0/hLR9PftDY8oMyzOBErSqjMjZ6OTkFFgk3dI9rHU72C1KL9Jh5uHwEQchBmg=
              f14864fffdcab725d9eac6d4f4c07be05a35f59a 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmQc3KUZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVnYZDACh1Bcj8Yu3t8pO22SKWJnz8Ndw9Hvw+ifLaRxFUxKtqUYvy3CIl2qt8k7V13M25qw0061SKgcvNdjtkOhdmtFHNAbqryy0nK9oSZ2GfndmJfMxm9ixF/CcHrx+MmsklEz2woApViHW5PrmgKvZNsStQ5NM457Yx3B4nsT9b8t03NzdNiZRM+RZOkZ+4OdSbiB6hYuTqEFIi2YM+gfVM5Z7H8sEFBkUCtuwUjFGaWThZGGhAcqD5E7p/Lkjv4e4tzyHOzHDgdd+OCAkcbib6/E3Q1MlQ1x7CKpJ190T8R35CzAIMBVoTSI+Ov7OKw1OfGdeCvMVJsKUvqY3zrPawmJB6pG7GoVPEu5pU65H51U3Plq3GhsekUrKWY/BSHV9FOqpKZdnxOAllfWcjLYpbC/fM3l8uuQVcPAs89GvWKnDuE/NWCDYzDAYE++s/H4tP3Chv6yQbPSv/lbccst7OfLLDtXgRHIyEWLo392X3mWzhrkNtfJkBdi39uH9Aoh7pN0=
 ea6ce48b4fd09fb79c4e34cc5750c805699a53 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmQ3860ZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVk3gDACIIcQxKfis/r5UNj7SqyFhQxUCo8Njp7zdLFv3CSWFdFiOpQONI7Byt9KjwedUkUK9tqdb03V7W32ZSBTrNLM11uHY9E5Aknjoza4m+aIGbamEVRWIIHXjUZEMKS9QcY8ElbDvvPu/xdZjyTEjNNiuByUpPUcJXVzpKrHm8Wy3GWDliYBuu68mzFIX3JnZKscdK4EjCAfDysSwwfLeBMpd0Rk+SgwjDwyPWAAyU3yDPNmlUn8qTGHjXxU3vsHCXpoJWkfKmQ9n++23WEpM9vC8zx2TIy70+gFUvKG77+Ucv+djQxHRv0L6L5qUSBJukD3R3nml1xu6pUeioBHepRmTUWgPbHa/gQ+J2Pw+rPCK51x0EeT0SJjxUR2mmMLbk8N2efM35lEjF/sNxotTq17Sv9bjwXhue6BURxpQDEyOuSaS0IlF56ndXtE/4FX3H6zgU1+3jw5iBWajr1E04QjPlSOJO7nIKYM9Jq3VpHR7MiFwfT46pJEfw9pNgZX2b8o=
              f952be90b0514a576dcc8bbe758ce3847faba9bb 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmQ+ZaoZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVuDOC/90SQ3UjXmByAaT5qr4bd3sVGt12lXlaKdyDxY0JMSKyHMUnb4YltHzNFxiUku10aRsRvJt5denTGeaOvAYbbXE7nbZJuyLD9rvfFTCe6EVx7kymCBwSbobKMzD79QHAFU7xu036gs7rmwyc++F4JF4IOrT4bjSYY5/8g0uLAHUexnn49QfQ5OYr325qShDFLjUZ7aH0yxA/gEr2MfXQmbIEc0eJJQXD1EhDkpSJFNIKzwWMOT1AhFk8kTlDqqbPnW7sDxTW+v/gGjAFYLHi8GMLEyrBQdEqytN7Pl9XOPXt/8RaDfIzYfl0OHxh2l1Y1MuH/PHrWO4PBPsr82QI2mxufYKuujpFMPr4PxXXl2g31OKhI8jJj+bHr62kGIOJCxZ8EPPGKXPGyoOuIVa0MeHmXxjb9kkj0SALjlaUvZrSENzRTsQXDNHQa+iDaITKLmItvLsaTEz9DJzGmI20shtJYcx4lqHsTgtMZfOtR5tmUknAFUUBZfUwvwULD4LmNI=
              fc445f8abcf90b33db7c463816a1b3560681767f 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmRTok8ZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVpZ5DACBv33k//ovzSbyH5/q+Xhk3TqNRY8IDOjoEhvDyu0bJHsvygOGXLUtHpQPth1RA4/c+AVNJrUeFvT02sLqqP2d9oSA9HEAYpOuzwgr1A+1o+Q2GyfD4cElP6KfiEe8oyFVOB0rfBgWNei1C0nnrhChQr5dOPR63uAFhHzkEsgsTFS7ONxZ1DHbe7gRV8OMMf1MatAtRzRexQJCqyNv7WodQdrKtjHqPKtlWl20dbwTHhzeiZbtjiTe0CVXVsOqnA1DQkO/IaiKQrn3zWdGY5ABbqQ1K0ceLcej4NFOeLo9ZrShndU3BuFUa9Dq9bnPYOI9wMqGoDh/GdTZkZEzBy5PTokY3AJHblbub49pi8YTenFcPdtd/v71AaNi3TKa45ZNhYVkPmRETYweHkLs3CIrSyeiBwU4RGuQZVD/GujAQB5yhk0w+LPMzBsHruD4vsgXwIraCzQIIJTjgyxKuAJGdGNUFYyxEpUkgz5G6MFrBKe8HO69y3Pm/qDNZ2maV8k=
              da372c745e0f053bb7a64e74cccd15810d96341d 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmSB7WkZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVoy+C/4zwO+Wxc3wr0aEzjVqAss7FuGS5e66H+0T3WzVgKIRMqiiOmUmmiNf+XloXlX4TOwoh9j9GNEpoZfV6TSwFSqV0LALaVIRRwrkJBDhnqw4eNBZbK5aBWNa2/21dkHecxF4KG3ai9kLwy2mtHxkDIy8T2LPvdx8pfNcYT4PZ19x2itqZLouBJqiZYehsqeMLNF2vRqkq+rQ+D2sFGLljgPo0JlpkOZ4IL7S/cqTOBG1sQ6KJK+hAE1kF1lhvK796VhKKXVnWVgqJLyg7ZI6168gxeFv5cyCtb+FUXJJ/5SOkxaCKJf3mg3DIYi3G7xjwB5CfUGW8A2qexgEjXeV42Mu7/Mkmn/aeTdL0UcRK3oBVHJwqt/fJlGFqVWt4/9g9KW5mJvTDQYBo/zjLyvKFEbnSLzhEP+9SvthCrtX0UYkKxOGi2M2Z7e9wgBB0gY8a36kA739lkNu6r3vH/FVh0aPTMWukLToELS90WgfViNr16lDnCeDjMgg97OKxWdOW6U=
 a4ab29605ffa0bae5d3208eaa21a95427ff92 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmSUEeMZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVlJnC/98qGmpi0gHbsoCPfoxgV2uSE4XAXZXPvbHqKAVUVJbkQoS0L2jighUArPZsduRjD+nSf/jO951/DmnxIwXfF5qA2dP1eBnjSmXS3xslmqD7nUw+pP8mKUQvXky+AbiL5onWw4gRtsqTZg4DYnPMeaE/eIUy/j60kXsf6gaDkQSAF/+9vB5UcVI1z7gKY/nE5pGW6cS9kPd/BEg2icficaOHXcetQFi53Gcy5kLEaYc9f8RUrvc0Z9jDkZSlmTHfTLOY+1hlFZ2FRAvL1Ikh7Ks+85LWuqs1ZYIdB6ucudhLW1dGd/ZyD0iU82e0XrU/tm6oDBdeSFOy1AAXN5pern18VcPeaT/zGgN7DG1LW9jISbYFzLwvHwzTMKSVgq4HSfeTHiSKoWp0qAbcFHUYfC4L1Heqd/UfzVN/1/9eSj69Hbjff8+E6OOF15Ky2gtr8PSyP7WIu9rTueUUoWIMG99btq5OYvEbmWgHuHIcJBUEJOalvhrZePbTW3v22Eh45M=
              bb42988c7e156931b0ff1e93732b98173ebbcb7f 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmSUPXUZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVvYTC/wP7f8RITHgCO8djHUsnRs60P2mlEJQ71TDA3dqgdBIr3tWMELfcZMZnOTtaw4eqKemLauxa69MHgj2y++VMnfJx1pW5G61G8ZFfLjwFvAqqmXnnT6RVjo7sPuKSkL28C9NWwrLIRk5SGWK52W56Slz0bW1yhJBOV8BEIgZM5ucs4froYTxgAP8xprbLyPIroAJEtPNU3mkOXuPPGQ/zGO9czJ9sfYHU3bPmskf3YLqWAKQdCmxQgv44QluRVWoek6caIUA04mJwwlBdCCPZnr8hvaptZeYv2hhPw7CzDfWwMkyBYzmoUAZIgu/eYPtDRtxeIlEYC2WP+DQy5R+kK+X/nfxe8kVL9USow5MZZ54tmPbrwUO/dkWOWiK5NyqYnFjBDaq24XKUoPC7p7mGkfzQPNCiKcQO3qcUtiIb7tzz0olWemD2z86ws8kaEK8GSOgpBK71KOzrPZt8B01Nb+seahftCN5HxALAJSM6VRxYJFgYMFFxid+zNwEstuNipo=
 ffc7209bbae5804a53084c9dc2d41139e88c867 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmSmyeIZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVn/CC/9l24Feazay+kN3rOCvRqOOQO0Xx47+Lx5xaC4mgSAs7fkefY0ru4gnKRQkYskIksUzJX0P6aGrS3RH3y+DzxPhha75Ufq1abD8c1NJ2mUzW/DnoEI9zKnprkUdet8cwwLzNDhuWqjG6DY1ETwWpYVHo01Yv5FjDOdbMfPJ92yyF2AxLNTjkHNNfn0dpJE+/Sz8WjKsjPtTB432ZhvmfDsWgW+fTOlVATEyRqP4vNMWxPKPYif7KvH5U8vPAvX4i5Ox+csNeFQTUGV6KfgpAjXuJc2AEGr644KfpiMIyvWvEDewPAoGR+BUBz8jjT5KqBxc/9RJ8wEruCZIEKXxMAta+G+wWJyXZgKU1UN4x6mQT4RscnvX/1jMZx7zzqTSq2fe0Ddw/ta2aZtbp0JLJ5NmqiFLaKdDDdTAAONn+dBLQMO0+NNm9bOOafqI8edsOw3WoXmOVxbpdBrzIP5x18qNRU9gcTxxPqN5yy97dhsKyRpdbMVruxp1NUWeTBywARI=
+af4e0e8b787e1b77a8059926b123730a4cd01 0 iQHNBAABCgA3FiEEH2b4zfZU6QXBHaBhoR4BzQ4F2VYFAmTQs9cZHGFscGhhcmVAcmFwaGFlbGdvbWVzLmRldgAKCRChHgHNDgXZVgKODACTVTvl32CwG8xodKC9BPHmdzU4IXJb9fweHfMjsnx5rxPrOMQ8/PL1X7spR5qD7uTvvz+3ceML0WFqSBcF8R/Tt3dV4bacpKLbFTvnOToExmuWzhZnOzL6FVIOkHsSL5u2geA0o6c/y7vxglCwUZmSCAgZLxPC8CPv1PMQ1wRjHPygaZR2dDtxktFrfrZmU7uY61rY3VBG7Z5GhT9JF0biS7/K5nN687yybj76Gn7Kw/TMDK4GKCboVydRBp0poxSp8I+fty2N0Trpsw47CQp6HcBHq1FPrIv587+7X9VgajkC/+ECWBwdlo1pA5GlhJP6/4j8jvcAteFp0HS24z++NT0AYUB4UBgCCmg5hdDeF8j6A7SLcpf+YfbIwiGPkSRfIBeT+bhBJVDV4gbhoE02BMymU42OmaMqC1W8YI32WhugAfZJNPmJzdeNO7PNjTPNnjSjFzAHuQVS5Z9SvfctvJG532hygJkR+bCeaHzwAebyXkopRLm4PUpWcazoEes=

.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
              c3484ddbdb9621256d597ed86b90d229c59c2af9 5.0.1
 ada9b8d51bef24c5cb4cdca4243f0db694ab6e 5.0.2
              e386b5f4f8360dbb43a576dd9b1368e386fefa5b 5.1rc0
              e91930d712e8507d1bc1b2dffd96c83edc4cbed3 5.1
              a4e32fd539ab41489a51b2aa88bda9a73b839562 5.1.1
 e52f2b62f4768aa0d988936c929dc7c4a41a0 5.1.2
 f9561099de77c684c00f76507f11e46ebe8 5.2rc0
              ca3dca416f8d5863ca6f5a4a6a6bb835dcd5feeb 5.2
              a50fecefa691c9b72a99e49aa6fe9dd13943c2bf 5.2.1
              b4c82b70418022e67cc0e69b1aa3c3aa43aa1d29 5.2.2
 a0102c05c7852c8215ef6cf21d809927586b69 5.3rc0
              e4344e463c0c888a2f437b78b5982ecdf3f6650a 5.3rc1
 f5410dfc8a64bb587d19637deb95d378fd1eb5c 5.3
 d121acbb82e65fe4dd3c2318a1b61981b958492 5.3.1
 fca7e8449a847e3cf1054f2c07b51237699fad3 5.3.2
 ce8e7515036d3431a03aaeb7bc72dd96cb1112 5.4rc0
              cf3e07d7648a4371ce584d15dd692e7a6845792f 5.4
 cbdbdbb05dcd6bb814eb9bbdd982211b28 5.4.1
 ea9c86fac8974cd74dc12ea681c8986eb6da6c4 5.4.2
 c5de797e5416f9b588940f4608269b4d50a 5.5rc0
 fc3c5fbc65f6fe85d70ea63923b8767dda4f2e0 5.5
              f62bb5d07848ca598aa860a517394130b61bf2ee 5.5.1
              07731064ac41dacdf0ec869ebd05c2e848c14fbf 5.5.2
 e06a7ab9e0d5c65af4e511aee1e0342998799df 5.6rc0
 c17d63fdabd009e70bf994e5efb7db422f4f7f 5.6
 d5189a57405ceca5aa244052c9f948977f4699b 5.6.1
 da65e3cf3706ff41e08b311381c588440c27baf 5.7rc0
 e2e7300f4302b02412b0b734717697049494c4c 5.7
              d5d9177c0045d206db575bae6daa98e2cb2fe5bc 5.7.1
              f67b8946bb1b6cfa8328dbf8d6a9128b69ccdcb4 5.8rc0
 d2b62d716b095507effaa8d56f87cd27ba659ab 5.8rc1
 f2c53fb24506c9e9fb4639871b13b19a85f8a 5.8
 dc27fd9fd076d6a031a08fcaace659afe2fe3 5.8.1
              d7515d29761d5ada7d9c765f517db67db75dea9a 5.9rc0
 d406b03607cdb8c06cb04c44efcc9a79d9a2 5.9rc1
              53221078e0de65d1a821ce5311dec45a7a978301 5.9
 a60679cf619e14cee9442f865fcf31b142cb9f 5.9.1
 b18aaaddd654756be40dec59d90f2643be 5.9.2
 ee0244fc1cf889ae543d2ce0ec45201ae0be6e1 5.9.3
              a44bb185f6bdbecc754996d8386722e2f0123b0a 6.0rc0
 d08b289e2e526259d7d5ea32b70fe76d5b327d7 6.0
 fdf4cca80cb9ae40537a90995e6bd163ebc0b 6.0.1
              75676122c2bf7594ac732b7388db4c74c648b365 6.0.2
              dcec16e799ddb6d33fcd11b04af530250a417a58 6.0.3
              c00d3ce4e94bb0ee8d809e25e1dcb2a5fab84e2c 6.1rc0
              d4486810a1795fba9521449b8885ced034f3a6dd 6.1
 bd6bcd31dd1ebb63b8914b00064f96297267af7 6.1.1
 ddd5e1f5f67438af85d12e4ce6c39021dde9916 6.1.2
 b10151b962108f65bfa12b3918b1021ca334f73 6.1.3
 cc5f74ff7f0f4ac2427096bddbe102dbc2453ae 6.1.4
 de6f5d724bba7bf1669e2838f196962bb7528 6.2rc0
 a5fa3cf52f936e0de3f1e507c818bee5ece6b 6.2
              f69bffd00abe3a1b94d1032eb2c92e611d16a192 6.2.1
              b5c8524827d20fe2e0ca8fb1234a0fe35a1a36c7 6.2.2
              dbdee8ac3e3fcdda1fa55b90c0a235125b7f8e6f 6.2.3
              a3356ab610fc50000cf0ba55c424a4d96da11db7 6.3rc0
 f1dba53c961dfdb875c8469adc96fa999cfbed 6.3.0
 f1dba53c961dfdb875c8469adc96fa999cfbed 6.3
 f1dba53c961dfdb875c8469adc96fa999cfbed 6.3.0
              0000000000000000000000000000000000000000 6.3.0
              c890d8b8bc59b18e5febf60caada629df5356ee2 6.3.1
 b13a3ae0e29a5d4f485393e516cfbb057d0 6.3.2
              8830004967ad865ead89c28a410405a6e71e0796 6.3.3
 de4896508e8ec387b33eb30d8aab78d1c8e9e4 6.4rc0
              f14864fffdcab725d9eac6d4f4c07be05a35f59a 6.4
 ea6ce48b4fd09fb79c4e34cc5750c805699a53 6.4.1
              f952be90b0514a576dcc8bbe758ce3847faba9bb 6.4.2
              fc445f8abcf90b33db7c463816a1b3560681767f 6.4.3
              da372c745e0f053bb7a64e74cccd15810d96341d 6.4.4
 a4ab29605ffa0bae5d3208eaa21a95427ff92 6.4.5
              bb42988c7e156931b0ff1e93732b98173ebbcb7f 6.5rc0
 ffc7209bbae5804a53084c9dc2d41139e88c867 6.5
+af4e0e8b787e1b77a8059926b123730a4cd01 6.5.1

contrib/perf.py

0 +1 -1

              # perf.py - performance test routines
              '''helper extension to measure performance
              Configurations
              ==============
              ``perf``
              --------
              ``all-timing``
                  When set, additional statistics will be reported for each benchmark: best,
                  worst, median average. If not set only the best timing is reported
                  (default: off).
              ``presleep``
                number of second to wait before any group of runs (default: 1)
              ``pre-run``
                number of run to perform before starting measurement.
              ``profile-benchmark``
                Enable profiling for the benchmarked section.
                (The first iteration is benchmarked)
              ``run-limits``
                Control the number of runs each benchmark will perform. The option value
                should be a list of `<time>-<numberofrun>` pairs. After each run the
                conditions are considered in order with the following logic:
                    If benchmark has been running for <time> seconds, and we have performed
                    <numberofrun> iterations, stop the benchmark,
                The default value is: `3.0-100, 10.0-3`
              ``stub``
                  When set, benchmarks will only be run once, useful for testing
                  (default: off)
              '''
              # "historical portability" policy of perf.py:
              #
              # We have to do:
              # - make perf.py "loadable" with as wide Mercurial version as possible
              #   This doesn't mean that perf commands work correctly with that Mercurial.
              #   BTW, perf.py itself has been available since 1.1 (or eb240755386d).
              # - make historical perf command work correctly with as wide Mercurial
              #   version as possible
              #
              # We have to do, if possible with reasonable cost:
              # - make recent perf command for historical feature work correctly
              #   with early Mercurial
              #
              # We don't have to do:
              # - make perf command for recent feature work correctly with early
              #   Mercurial
              import contextlib
              import functools
              import gc
              import os
              import random
              import shutil
              import struct
              import sys
              import tempfile
              import threading
              import time
              import mercurial.revlog
              from mercurial import (
                  changegroup,
                  cmdutil,
                  commands,
                  copies,
                  error,
                  extensions,
                  hg,
                  mdiff,
                  merge,
                  util,
              )
              # for "historical portability":
              # try to import modules separately (in dict order), and ignore
              # failure, because these aren't available with early Mercurial
              try:
                  from mercurial import branchmap  # since 2.5 (or bcee63733aad)
              except ImportError:
                  pass
              try:
                  from mercurial import obsolete  # since 2.3 (or ad0d6c2b3279)
              except ImportError:
                  pass
              try:
                  from mercurial import registrar  # since 3.7 (or 37d50250b696)
                  dir(registrar)  # forcibly load it
              except ImportError:
                  registrar = None
              try:
                  from mercurial import repoview  # since 2.5 (or 3a6ddacb7198)
              except ImportError:
                  pass
              try:
                  from mercurial.utils import repoviewutil  # since 5.0
              except ImportError:
                  repoviewutil = None
              try:
                  from mercurial import scmutil  # since 1.9 (or 8b252e826c68)
              except ImportError:
                  pass
              try:
                  from mercurial import setdiscovery  # since 1.9 (or cb98fed52495)
              except ImportError:
                  pass
              try:
                  from mercurial import profiling
              except ImportError:
                  profiling = None
              try:
                  from mercurial.revlogutils import constants as revlog_constants
                  perf_rl_kind = (revlog_constants.KIND_OTHER, b'created-by-perf')
                  def revlog(opener, *args, **kwargs):
                      return mercurial.revlog.revlog(opener, perf_rl_kind, *args, **kwargs)
              except (ImportError, AttributeError):
                  perf_rl_kind = None
                  def revlog(opener, *args, **kwargs):
                      return mercurial.revlog.revlog(opener, *args, **kwargs)
              def identity(a):
                  return a
              try:
                  from mercurial import pycompat
                  getargspec = pycompat.getargspec  # added to module after 4.5
                  _byteskwargs = pycompat.byteskwargs  # since 4.1 (or fbc3f73dc802)
                  _sysstr = pycompat.sysstr  # since 4.0 (or 2219f4f82ede)
                  _bytestr = pycompat.bytestr  # since 4.2 (or b70407bd84d5)
                  _xrange = pycompat.xrange  # since 4.8 (or 7eba8f83129b)
                  fsencode = pycompat.fsencode  # since 3.9 (or f4a5e0e86a7e)
                  if pycompat.ispy3:
                      _maxint = sys.maxsize  # per py3 docs for replacing maxint
                  else:
                      _maxint = sys.maxint
              except (NameError, ImportError, AttributeError):
                  import inspect
                  getargspec = inspect.getargspec
                  _byteskwargs = identity
                  _bytestr = str
                  fsencode = identity  # no py3 support
                  _maxint = sys.maxint  # no py3 support
                  _sysstr = lambda x: x  # no py3 support
                  _xrange = xrange
              try:
                  # 4.7+
                  queue = pycompat.queue.Queue
              except (NameError, AttributeError, ImportError):
                  # <4.7.
                  try:
                      queue = pycompat.queue
                  except (NameError, AttributeError, ImportError):
                      import Queue as queue
              try:
                  from mercurial import logcmdutil
                  makelogtemplater = logcmdutil.maketemplater
              except (AttributeError, ImportError):
                  try:
                      makelogtemplater = cmdutil.makelogtemplater
                  except (AttributeError, ImportError):
                      makelogtemplater = None
              # for "historical portability":
              # define util.safehasattr forcibly, because util.safehasattr has been
              # available since 1.9.3 (or 94b200a11cf7)
              _undefined = object()
              def safehasattr(thing, attr):
                  return getattr(thing, _sysstr(attr), _undefined) is not _undefined
              setattr(util, 'safehasattr', safehasattr)
              # for "historical portability":
              # define util.timer forcibly, because util.timer has been available
              # since ae5d60bb70c9
              if safehasattr(time, 'perf_counter'):
                  util.timer = time.perf_counter
              elif os.name == b'nt':
                  util.timer = time.clock
              else:
                  util.timer = time.time
              # for "historical portability":
              # use locally defined empty option list, if formatteropts isn't
              # available, because commands.formatteropts has been available since
              # 3.2 (or 7a7eed5176a4), even though formatting itself has been
              # available since 2.2 (or ae5f92e154d3)
              formatteropts = getattr(
                  cmdutil, "formatteropts", getattr(commands, "formatteropts", [])
              )
              # for "historical portability":
              # use locally defined option list, if debugrevlogopts isn't available,
              # because commands.debugrevlogopts has been available since 3.7 (or
              # 5606f7d0d063), even though cmdutil.openrevlog() has been available
              # since 1.9 (or a79fea6b3e77).
              revlogopts = getattr(
                  cmdutil,
                  "debugrevlogopts",
                  getattr(
                      commands,
                      "debugrevlogopts",
                      [
                          (b'c', b'changelog', False, b'open changelog'),
                          (b'm', b'manifest', False, b'open manifest'),
                          (b'', b'dir', False, b'open directory manifest'),
                      ],
                  ),
              )
              cmdtable = {}
              # for "historical portability":
              # define parsealiases locally, because cmdutil.parsealiases has been
              # available since 1.5 (or 6252852b4332)
              def parsealiases(cmd):
                  return cmd.split(b"|")
              if safehasattr(registrar, 'command'):
                  command = registrar.command(cmdtable)
              elif safehasattr(cmdutil, 'command'):
                  command = cmdutil.command(cmdtable)
                  if 'norepo' not in getargspec(command).args:
                      # for "historical portability":
                      # wrap original cmdutil.command, because "norepo" option has
                      # been available since 3.1 (or 75a96326cecb)
                      _command = command
                      def command(name, options=(), synopsis=None, norepo=False):
                          if norepo:
                              commands.norepo += b' %s' % b' '.join(parsealiases(name))
                          return _command(name, list(options), synopsis)
              else:
                  # for "historical portability":
                  # define "@command" annotation locally, because cmdutil.command
                  # has been available since 1.9 (or 2daa5179e73f)
                  def command(name, options=(), synopsis=None, norepo=False):
                      def decorator(func):
                          if synopsis:
                              cmdtable[name] = func, list(options), synopsis
                          else:
                              cmdtable[name] = func, list(options)
                          if norepo:
                              commands.norepo += b' %s' % b' '.join(parsealiases(name))
                          return func
                      return decorator
              try:
                  import mercurial.registrar
                  import mercurial.configitems
                  configtable = {}
                  configitem = mercurial.registrar.configitem(configtable)
                  configitem(
                      b'perf',
                      b'presleep',
                      default=mercurial.configitems.dynamicdefault,
                      experimental=True,
                  )
                  configitem(
                      b'perf',
                      b'stub',
                      default=mercurial.configitems.dynamicdefault,
                      experimental=True,
                  )
                  configitem(
                      b'perf',
                      b'parentscount',
                      default=mercurial.configitems.dynamicdefault,
                      experimental=True,
                  )
                  configitem(
                      b'perf',
                      b'all-timing',
                      default=mercurial.configitems.dynamicdefault,
                      experimental=True,
                  )
                  configitem(
                      b'perf',
                      b'pre-run',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'profile-benchmark',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'run-limits',
                      default=mercurial.configitems.dynamicdefault,
                      experimental=True,
                  )
              except (ImportError, AttributeError):
                  pass
              except TypeError:
                  # compatibility fix for a11fd395e83f
                  # hg version: 5.2
                  configitem(
                      b'perf',
                      b'presleep',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'stub',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'parentscount',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'all-timing',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'pre-run',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'profile-benchmark',
                      default=mercurial.configitems.dynamicdefault,
                  )
                  configitem(
                      b'perf',
                      b'run-limits',
                      default=mercurial.configitems.dynamicdefault,
                  )
              def getlen(ui):
                  if ui.configbool(b"perf", b"stub", False):
                      return lambda x: 1
                  return len
              class noop:
                  """dummy context manager"""
                  def __enter__(self):
                      pass
                  def __exit__(self, *args):
                      pass
              NOOPCTX = noop()
              def gettimer(ui, opts=None):
                  """return a timer function and formatter: (timer, formatter)
                  This function exists to gather the creation of formatter in a single
                  place instead of duplicating it in all performance commands."""
                  # enforce an idle period before execution to counteract power management
                  # experimental config: perf.presleep
                  time.sleep(getint(ui, b"perf", b"presleep", 1))
                  if opts is None:
                      opts = {}
                  # redirect all to stderr unless buffer api is in use
                  if not ui._buffers:
                      ui = ui.copy()
                      uifout = safeattrsetter(ui, b'fout', ignoremissing=True)
                      if uifout:
                          # for "historical portability":
                          # ui.fout/ferr have been available since 1.9 (or 4e1ccd4c2b6d)
                          uifout.set(ui.ferr)
                  # get a formatter
                  uiformatter = getattr(ui, 'formatter', None)
                  if uiformatter:
                      fm = uiformatter(b'perf', opts)
                  else:
                      # for "historical portability":
                      # define formatter locally, because ui.formatter has been
                      # available since 2.2 (or ae5f92e154d3)
                      from mercurial import node
                      class defaultformatter:
                          """Minimized composition of baseformatter and plainformatter"""
                          def __init__(self, ui, topic, opts):
                              self._ui = ui
                              if ui.debugflag:
                                  self.hexfunc = node.hex
                              else:
                                  self.hexfunc = node.short
                          def __nonzero__(self):
                              return False
                          __bool__ = __nonzero__
                          def startitem(self):
                              pass
                          def data(self, **data):
                              pass
                          def write(self, fields, deftext, *fielddata, **opts):
                              self._ui.write(deftext % fielddata, **opts)
                          def condwrite(self, cond, fields, deftext, *fielddata, **opts):
                              if cond:
                                  self._ui.write(deftext % fielddata, **opts)
                          def plain(self, text, **opts):
                              self._ui.write(text, **opts)
                          def end(self):
                              pass
                      fm = defaultformatter(ui, b'perf', opts)
                  # stub function, runs code only once instead of in a loop
                  # experimental config: perf.stub
                  if ui.configbool(b"perf", b"stub", False):
                      return functools.partial(stub_timer, fm), fm
                  # experimental config: perf.all-timing
                  displayall = ui.configbool(b"perf", b"all-timing", True)
                  # experimental config: perf.run-limits
                  limitspec = ui.configlist(b"perf", b"run-limits", [])
                  limits = []
                  for item in limitspec:
                      parts = item.split(b'-', 1)
                      if len(parts) < 2:
                          ui.warn((b'malformatted run limit entry, missing "-": %s\n' % item))
                          continue
                      try:
                          time_limit = float(_sysstr(parts[0]))
                      except ValueError as e:
                          ui.warn(
                              (
                                  b'malformatted run limit entry, %s: %s\n'
                                  % (_bytestr(e), item)
                              )
                          )
                          continue
                      try:
                          run_limit = int(_sysstr(parts[1]))
                      except ValueError as e:
                          ui.warn(
                              (
                                  b'malformatted run limit entry, %s: %s\n'
                                  % (_bytestr(e), item)
                              )
                          )
                          continue
                      limits.append((time_limit, run_limit))
                  if not limits:
                      limits = DEFAULTLIMITS
                  profiler = None
                  if profiling is not None:
                      if ui.configbool(b"perf", b"profile-benchmark", False):
                          profiler = profiling.profile(ui)
                  prerun = getint(ui, b"perf", b"pre-run", 0)
                  t = functools.partial(
                      _timer,
                      fm,
                      displayall=displayall,
                      limits=limits,
                      prerun=prerun,
                      profiler=profiler,
                  )
                  return t, fm
              def stub_timer(fm, func, setup=None, title=None):
                  if setup is not None:
                      setup()
                  func()
              @contextlib.contextmanager
              def timeone():
                  r = []
                  ostart = os.times()
                  cstart = util.timer()
                  yield r
                  cstop = util.timer()
                  ostop = os.times()
                  a, b = ostart, ostop
                  r.append((cstop - cstart, b[0] - a[0], b[1] - a[1]))
              # list of stop condition (elapsed time, minimal run count)
              DEFAULTLIMITS = (
                  (3.0, 100),
                  (10.0, 3),
              )
              @contextlib.contextmanager
              def noop_context():
                  yield
              def _timer(
                  fm,
                  func,
                  setup=None,
                  context=noop_context,
                  title=None,
                  displayall=False,
                  limits=DEFAULTLIMITS,
                  prerun=0,
                  profiler=None,
              ):
                  gc.collect()
                  results = []
                  begin = util.timer()
                  count = 0
                  if profiler is None:
                      profiler = NOOPCTX
                  for i in range(prerun):
                      if setup is not None:
                          setup()
                      with context():
                          func()
                  keepgoing = True
                  while keepgoing:
                      if setup is not None:
                          setup()
                      with context():
                          with profiler:
                              with timeone() as item:
                                  r = func()
                      profiler = NOOPCTX
                      count += 1
                      results.append(item[0])
                      cstop = util.timer()
                      # Look for a stop condition.
                      elapsed = cstop - begin
                      for t, mincount in limits:
                          if elapsed >= t and count >= mincount:
                              keepgoing = False
                              break
                  formatone(fm, results, title=title, result=r, displayall=displayall)
              def formatone(fm, timings, title=None, result=None, displayall=False):
                  count = len(timings)
                  fm.startitem()
                  if title:
                      fm.write(b'title', b'! %s\n', title)
                  if result:
                      fm.write(b'result', b'! result: %s\n', result)
                  def display(role, entry):
                      prefix = b''
                      if role != b'best':
                          prefix = b'%s.' % role
                      fm.plain(b'!')
                      fm.write(prefix + b'wall', b' wall %f', entry[0])
                      fm.write(prefix + b'comb', b' comb %f', entry[1] + entry[2])
                      fm.write(prefix + b'user', b' user %f', entry[1])
                      fm.write(prefix + b'sys', b' sys %f', entry[2])
                      fm.write(prefix + b'count', b' (%s of %%d)' % role, count)
                      fm.plain(b'\n')
                  timings.sort()
                  min_val = timings[0]
                  display(b'best', min_val)
                  if displayall:
                      max_val = timings[-1]
                      display(b'max', max_val)
                      avg = tuple([sum(x) / count for x in zip(*timings)])
                      display(b'avg', avg)
                      median = timings[len(timings) // 2]
                      display(b'median', median)
              # utilities for historical portability
              def getint(ui, section, name, default):
                  # for "historical portability":
                  # ui.configint has been available since 1.9 (or fa2b596db182)
                  v = ui.config(section, name, None)
                  if v is None:
                      return default
                  try:
                      return int(v)
                  except ValueError:
                      raise error.ConfigError(
                          b"%s.%s is not an integer ('%s')" % (section, name, v)
                      )
              def safeattrsetter(obj, name, ignoremissing=False):
                  """Ensure that 'obj' has 'name' attribute before subsequent setattr
                  This function is aborted, if 'obj' doesn't have 'name' attribute
                  at runtime. This avoids overlooking removal of an attribute, which
                  breaks assumption of performance measurement, in the future.
                  This function returns the object to (1) assign a new value, and
                  (2) restore an original value to the attribute.
                  If 'ignoremissing' is true, missing 'name' attribute doesn't cause
                  abortion, and this function returns None. This is useful to
                  examine an attribute, which isn't ensured in all Mercurial
                  versions.
                  """
                  if not util.safehasattr(obj, name):
                      if ignoremissing:
                          return None
                      raise error.Abort(
                          (
                              b"missing attribute %s of %s might break assumption"
                              b" of performance measurement"
                          )
                          % (name, obj)
                      )
                  origvalue = getattr(obj, _sysstr(name))
                  class attrutil:
                      def set(self, newvalue):
                          setattr(obj, _sysstr(name), newvalue)
                      def restore(self):
                          setattr(obj, _sysstr(name), origvalue)
                  return attrutil()
              # utilities to examine each internal API changes
              def getbranchmapsubsettable():
                  # for "historical portability":
                  # subsettable is defined in:
                  # - branchmap since 2.9 (or 175c6fd8cacc)
                  # - repoview since 2.5 (or 59a9f18d4587)
                  # - repoviewutil since 5.0
                  for mod in (branchmap, repoview, repoviewutil):
                      subsettable = getattr(mod, 'subsettable', None)
                      if subsettable:
                          return subsettable
                  # bisecting in bcee63733aad::59a9f18d4587 can reach here (both
                  # branchmap and repoview modules exist, but subsettable attribute
                  # doesn't)
                  raise error.Abort(
                      b"perfbranchmap not available with this Mercurial",
                      hint=b"use 2.5 or later",
                  )
              def getsvfs(repo):
                  """Return appropriate object to access files under .hg/store"""
                  # for "historical portability":
                  # repo.svfs has been available since 2.3 (or 7034365089bf)
                  svfs = getattr(repo, 'svfs', None)
                  if svfs:
                      return svfs
                  else:
                      return getattr(repo, 'sopener')
              def getvfs(repo):
                  """Return appropriate object to access files under .hg"""
                  # for "historical portability":
                  # repo.vfs has been available since 2.3 (or 7034365089bf)
                  vfs = getattr(repo, 'vfs', None)
                  if vfs:
                      return vfs
                  else:
                      return getattr(repo, 'opener')
              def repocleartagscachefunc(repo):
                  """Return the function to clear tags cache according to repo internal API"""
                  if util.safehasattr(repo, b'_tagscache'):  # since 2.0 (or 9dca7653b525)
                      # in this case, setattr(repo, '_tagscache', None) or so isn't
                      # correct way to clear tags cache, because existing code paths
                      # expect _tagscache to be a structured object.
                      def clearcache():
                          # _tagscache has been filteredpropertycache since 2.5 (or
                          # 98c867ac1330), and delattr() can't work in such case
                          if '_tagscache' in vars(repo):
                              del repo.__dict__['_tagscache']
                      return clearcache
                  repotags = safeattrsetter(repo, b'_tags', ignoremissing=True)
                  if repotags:  # since 1.4 (or 5614a628d173)
                      return lambda: repotags.set(None)
                  repotagscache = safeattrsetter(repo, b'tagscache', ignoremissing=True)
                  if repotagscache:  # since 0.6 (or d7df759d0e97)
                      return lambda: repotagscache.set(None)
                  # Mercurial earlier than 0.6 (or d7df759d0e97) logically reaches
                  # this point, but it isn't so problematic, because:
                  # - repo.tags of such Mercurial isn't "callable", and repo.tags()
                  #   in perftags() causes failure soon
                  # - perf.py itself has been available since 1.1 (or eb240755386d)
                  raise error.Abort(b"tags API of this hg command is unknown")
              # utilities to clear cache
              def clearfilecache(obj, attrname):
                  unfiltered = getattr(obj, 'unfiltered', None)
                  if unfiltered is not None:
                      obj = obj.unfiltered()
                  if attrname in vars(obj):
                      delattr(obj, attrname)
                  obj._filecache.pop(attrname, None)
              def clearchangelog(repo):
                  if repo is not repo.unfiltered():
                      object.__setattr__(repo, '_clcachekey', None)
                      object.__setattr__(repo, '_clcache', None)
                  clearfilecache(repo.unfiltered(), 'changelog')
              # perf commands
              @command(b'perf::walk|perfwalk', formatteropts)
              def perfwalk(ui, repo, *pats, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  m = scmutil.match(repo[None], pats, {})
                  timer(
                      lambda: len(
                          list(
                              repo.dirstate.walk(m, subrepos=[], unknown=True, ignored=False)
                          )
                      )
                  )
                  fm.end()
              @command(b'perf::annotate|perfannotate', formatteropts)
              def perfannotate(ui, repo, f, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  fc = repo[b'.'][f]
                  timer(lambda: len(fc.annotate(True)))
                  fm.end()
              @command(
                  b'perf::status|perfstatus',
                  [
                      (b'u', b'unknown', False, b'ask status to look for unknown files'),
                      (b'', b'dirstate', False, b'benchmark the internal dirstate call'),
                  ]
                  + formatteropts,
              )
              def perfstatus(ui, repo, **opts):
                  """benchmark the performance of a single status call
                  The repository data are preserved between each call.
                  By default, only the status of the tracked file are requested. If
                  `--unknown` is passed, the "unknown" files are also tracked.
                  """
                  opts = _byteskwargs(opts)
                  # m = match.always(repo.root, repo.getcwd())
                  # timer(lambda: sum(map(len, repo.dirstate.status(m, [], False, False,
                  #                                                False))))
                  timer, fm = gettimer(ui, opts)
                  if opts[b'dirstate']:
                      dirstate = repo.dirstate
                      m = scmutil.matchall(repo)
                      unknown = opts[b'unknown']
                      def status_dirstate():
                          s = dirstate.status(
                              m, subrepos=[], ignored=False, clean=False, unknown=unknown
                          )
                          sum(map(bool, s))
                      if util.safehasattr(dirstate, 'running_status'):
                          with dirstate.running_status(repo):
                              timer(status_dirstate)
                              dirstate.invalidate()
                      else:
                          timer(status_dirstate)
                  else:
                      timer(lambda: sum(map(len, repo.status(unknown=opts[b'unknown']))))
                  fm.end()
              @command(b'perf::addremove|perfaddremove', formatteropts)
              def perfaddremove(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  try:
                      oldquiet = repo.ui.quiet
                      repo.ui.quiet = True
                      matcher = scmutil.match(repo[None])
                      opts[b'dry_run'] = True
                      if 'uipathfn' in getargspec(scmutil.addremove).args:
                          uipathfn = scmutil.getuipathfn(repo)
                          timer(lambda: scmutil.addremove(repo, matcher, b"", uipathfn, opts))
                      else:
                          timer(lambda: scmutil.addremove(repo, matcher, b"", opts))
                  finally:
                      repo.ui.quiet = oldquiet
                      fm.end()
              def clearcaches(cl):
                  # behave somewhat consistently across internal API changes
                  if util.safehasattr(cl, b'clearcaches'):
                      cl.clearcaches()
                  elif util.safehasattr(cl, b'_nodecache'):
                      # <= hg-5.2
                      from mercurial.node import nullid, nullrev
                      cl._nodecache = {nullid: nullrev}
                      cl._nodepos = None
              @command(b'perf::heads|perfheads', formatteropts)
              def perfheads(ui, repo, **opts):
                  """benchmark the computation of a changelog heads"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  cl = repo.changelog
                  def s():
                      clearcaches(cl)
                  def d():
                      len(cl.headrevs())
                  timer(d, setup=s)
                  fm.end()
              @command(
                  b'perf::tags|perftags',
                  formatteropts
                  + [
                      (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
                  ],
              )
              def perftags(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  repocleartagscache = repocleartagscachefunc(repo)
                  clearrevlogs = opts[b'clear_revlogs']
                  def s():
                      if clearrevlogs:
                          clearchangelog(repo)
                          clearfilecache(repo.unfiltered(), 'manifest')
                      repocleartagscache()
                  def t():
-                     return len(repo.tags())
+                     len(repo.tags())
                  timer(t, setup=s)
                  fm.end()
              @command(b'perf::ancestors|perfancestors', formatteropts)
              def perfancestors(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  heads = repo.changelog.headrevs()
                  def d():
                      for a in repo.changelog.ancestors(heads):
                          pass
                  timer(d)
                  fm.end()
              @command(b'perf::ancestorset|perfancestorset', formatteropts)
              def perfancestorset(ui, repo, revset, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  revs = repo.revs(revset)
                  heads = repo.changelog.headrevs()
                  def d():
                      s = repo.changelog.ancestors(heads)
                      for rev in revs:
                          rev in s
                  timer(d)
                  fm.end()
              @command(
                  b'perf::delta-find',
                  revlogopts + formatteropts,
                  b'-c|-m|FILE REV',
              )
              def perf_delta_find(ui, repo, arg_1, arg_2=None, **opts):
                  """benchmark the process of finding a valid delta for a revlog revision
                  When a revlog receives a new revision (e.g. from a commit, or from an
                  incoming bundle), it searches for a suitable delta-base to produce a delta.
                  This perf command measures how much time we spend in this process. It
                  operates on an already stored revision.
                  See `hg help debug-delta-find` for another related command.
                  """
                  from mercurial import revlogutils
                  import mercurial.revlogutils.deltas as deltautil
                  opts = _byteskwargs(opts)
                  if arg_2 is None:
                      file_ = None
                      rev = arg_1
                  else:
                      file_ = arg_1
                      rev = arg_2
                  repo = repo.unfiltered()
                  timer, fm = gettimer(ui, opts)
                  rev = int(rev)
                  revlog = cmdutil.openrevlog(repo, b'perf::delta-find', file_, opts)
                  deltacomputer = deltautil.deltacomputer(revlog)
                  node = revlog.node(rev)
                  p1r, p2r = revlog.parentrevs(rev)
                  p1 = revlog.node(p1r)
                  p2 = revlog.node(p2r)
                  full_text = revlog.revision(rev)
                  textlen = len(full_text)
                  cachedelta = None
                  flags = revlog.flags(rev)
                  revinfo = revlogutils.revisioninfo(
                      node,
                      p1,
                      p2,
                      [full_text],  # btext
                      textlen,
                      cachedelta,
                      flags,
                  )
                  # Note: we should probably purge the potential caches (like the full
                  # manifest cache) between runs.
                  def find_one():
                      with revlog._datafp() as fh:
                          deltacomputer.finddeltainfo(revinfo, fh, target_rev=rev)
                  timer(find_one)
                  fm.end()
              @command(b'perf::discovery|perfdiscovery', formatteropts, b'PATH')
              def perfdiscovery(ui, repo, path, **opts):
                  """benchmark discovery between local repo and the peer at given path"""
                  repos = [repo, None]
                  timer, fm = gettimer(ui, opts)
                  try:
                      from mercurial.utils.urlutil import get_unique_pull_path_obj
                      path = get_unique_pull_path_obj(b'perfdiscovery', ui, path)
                  except ImportError:
                      try:
                          from mercurial.utils.urlutil import get_unique_pull_path
                          path = get_unique_pull_path(b'perfdiscovery', repo, ui, path)[0]
                      except ImportError:
                          path = ui.expandpath(path)
                  def s():
                      repos[1] = hg.peer(ui, opts, path)
                  def d():
                      setdiscovery.findcommonheads(ui, *repos)
                  timer(d, setup=s)
                  fm.end()
              @command(
                  b'perf::bookmarks|perfbookmarks',
                  formatteropts
                  + [
                      (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
                  ],
              )
              def perfbookmarks(ui, repo, **opts):
                  """benchmark parsing bookmarks from disk to memory"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  clearrevlogs = opts[b'clear_revlogs']
                  def s():
                      if clearrevlogs:
                          clearchangelog(repo)
                      clearfilecache(repo, b'_bookmarks')
                  def d():
                      repo._bookmarks
                  timer(d, setup=s)
                  fm.end()
              @command(
                  b'perf::bundle',
                  [
                      (
                          b'r',
                          b'rev',
                          [],
                          b'changesets to bundle',
                          b'REV',
                      ),
                      (
                          b't',
                          b'type',
                          b'none',
                          b'bundlespec to use (see `hg help bundlespec`)',
                          b'TYPE',
                      ),
                  ]
                  + formatteropts,
                  b'REVS',
              )
              def perfbundle(ui, repo, *revs, **opts):
                  """benchmark the creation of a bundle from a repository
                  For now, this only supports "none" compression.
                  """
                  try:
                      from mercurial import bundlecaches
                      parsebundlespec = bundlecaches.parsebundlespec
                  except ImportError:
                      from mercurial import exchange
                      parsebundlespec = exchange.parsebundlespec
                  from mercurial import discovery
                  from mercurial import bundle2
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  cl = repo.changelog
                  revs = list(revs)
                  revs.extend(opts.get(b'rev', ()))
                  revs = scmutil.revrange(repo, revs)
                  if not revs:
                      raise error.Abort(b"not revision specified")
                  # make it a consistent set (ie: without topological gaps)
                  old_len = len(revs)
                  revs = list(repo.revs(b"%ld::%ld", revs, revs))
                  if old_len != len(revs):
                      new_count = len(revs) - old_len
                      msg = b"add %d new revisions to make it a consistent set\n"
                      ui.write_err(msg % new_count)
                  targets = [cl.node(r) for r in repo.revs(b"heads(::%ld)", revs)]
                  bases = [cl.node(r) for r in repo.revs(b"heads(::%ld - %ld)", revs, revs)]
                  outgoing = discovery.outgoing(repo, bases, targets)
                  bundle_spec = opts.get(b'type')
                  bundle_spec = parsebundlespec(repo, bundle_spec, strict=False)
                  cgversion = bundle_spec.params.get(b"cg.version")
                  if cgversion is None:
                      if bundle_spec.version == b'v1':
                          cgversion = b'01'
                      if bundle_spec.version == b'v2':
                          cgversion = b'02'
                  if cgversion not in changegroup.supportedoutgoingversions(repo):
                      err = b"repository does not support bundle version %s"
                      raise error.Abort(err % cgversion)
                  if cgversion == b'01':  # bundle1
                      bversion = b'HG10' + bundle_spec.wirecompression
                      bcompression = None
                  elif cgversion in (b'02', b'03'):
                      bversion = b'HG20'
                      bcompression = bundle_spec.wirecompression
                  else:
                      err = b'perf::bundle: unexpected changegroup version %s'
                      raise error.ProgrammingError(err % cgversion)
                  if bcompression is None:
                      bcompression = b'UN'
                  if bcompression != b'UN':
                      err = b'perf::bundle: compression currently unsupported: %s'
                      raise error.ProgrammingError(err % bcompression)
                  def do_bundle():
                      bundle2.writenewbundle(
                          ui,
                          repo,
                          b'perf::bundle',
                          os.devnull,
                          bversion,
                          outgoing,
                          bundle_spec.params,
                      )
                  timer(do_bundle)
                  fm.end()
              @command(b'perf::bundleread|perfbundleread', formatteropts, b'BUNDLE')
              def perfbundleread(ui, repo, bundlepath, **opts):
                  """Benchmark reading of bundle files.
                  This command is meant to isolate the I/O part of bundle reading as
                  much as possible.
                  """
                  from mercurial import (
                      bundle2,
                      exchange,
                      streamclone,
                  )
                  opts = _byteskwargs(opts)
                  def makebench(fn):
                      def run():
                          with open(bundlepath, b'rb') as fh:
                              bundle = exchange.readbundle(ui, fh, bundlepath)
                              fn(bundle)
                      return run
                  def makereadnbytes(size):
                      def run():
                          with open(bundlepath, b'rb') as fh:
                              bundle = exchange.readbundle(ui, fh, bundlepath)
                              while bundle.read(size):
                                  pass
                      return run
                  def makestdioread(size):
                      def run():
                          with open(bundlepath, b'rb') as fh:
                              while fh.read(size):
                                  pass
                      return run
                  # bundle1
                  def deltaiter(bundle):
                      for delta in bundle.deltaiter():
                          pass
                  def iterchunks(bundle):
                      for chunk in bundle.getchunks():
                          pass
                  # bundle2
                  def forwardchunks(bundle):
                      for chunk in bundle._forwardchunks():
                          pass
                  def iterparts(bundle):
                      for part in bundle.iterparts():
                          pass
                  def iterpartsseekable(bundle):
                      for part in bundle.iterparts(seekable=True):
                          pass
                  def seek(bundle):
                      for part in bundle.iterparts(seekable=True):
                          part.seek(0, os.SEEK_END)
                  def makepartreadnbytes(size):
                      def run():
                          with open(bundlepath, b'rb') as fh:
                              bundle = exchange.readbundle(ui, fh, bundlepath)
                              for part in bundle.iterparts():
                                  while part.read(size):
                                      pass
                      return run
                  benches = [
                      (makestdioread(8192), b'read(8k)'),
                      (makestdioread(16384), b'read(16k)'),
                      (makestdioread(32768), b'read(32k)'),
                      (makestdioread(131072), b'read(128k)'),
                  ]
                  with open(bundlepath, b'rb') as fh:
                      bundle = exchange.readbundle(ui, fh, bundlepath)
                      if isinstance(bundle, changegroup.cg1unpacker):
                          benches.extend(
                              [
                                  (makebench(deltaiter), b'cg1 deltaiter()'),
                                  (makebench(iterchunks), b'cg1 getchunks()'),
                                  (makereadnbytes(8192), b'cg1 read(8k)'),
                                  (makereadnbytes(16384), b'cg1 read(16k)'),
                                  (makereadnbytes(32768), b'cg1 read(32k)'),
                                  (makereadnbytes(131072), b'cg1 read(128k)'),
                              ]
                          )
                      elif isinstance(bundle, bundle2.unbundle20):
                          benches.extend(
                              [
                                  (makebench(forwardchunks), b'bundle2 forwardchunks()'),
                                  (makebench(iterparts), b'bundle2 iterparts()'),
                                  (
                                      makebench(iterpartsseekable),
                                      b'bundle2 iterparts() seekable',
                                  ),
                                  (makebench(seek), b'bundle2 part seek()'),
                                  (makepartreadnbytes(8192), b'bundle2 part read(8k)'),
                                  (makepartreadnbytes(16384), b'bundle2 part read(16k)'),
                                  (makepartreadnbytes(32768), b'bundle2 part read(32k)'),
                                  (makepartreadnbytes(131072), b'bundle2 part read(128k)'),
                              ]
                          )
                      elif isinstance(bundle, streamclone.streamcloneapplier):
                          raise error.Abort(b'stream clone bundles not supported')
                      else:
                          raise error.Abort(b'unhandled bundle type: %s' % type(bundle))
                  for fn, title in benches:
                      timer, fm = gettimer(ui, opts)
                      timer(fn, title=title)
                      fm.end()
              @command(
                  b'perf::changegroupchangelog|perfchangegroupchangelog',
                  formatteropts
                  + [
                      (b'', b'cgversion', b'02', b'changegroup version'),
                      (b'r', b'rev', b'', b'revisions to add to changegroup'),
                  ],
              )
              def perfchangegroupchangelog(ui, repo, cgversion=b'02', rev=None, **opts):
                  """Benchmark producing a changelog group for a changegroup.
                  This measures the time spent processing the changelog during a
                  bundle operation. This occurs during `hg bundle` and on a server
                  processing a `getbundle` wire protocol request (handles clones
                  and pull requests).
                  By default, all revisions are added to the changegroup.
                  """
                  opts = _byteskwargs(opts)
                  cl = repo.changelog
                  nodes = [cl.lookup(r) for r in repo.revs(rev or b'all()')]
                  bundler = changegroup.getbundler(cgversion, repo)
                  def d():
                      state, chunks = bundler._generatechangelog(cl, nodes)
                      for chunk in chunks:
                          pass
                  timer, fm = gettimer(ui, opts)
                  # Terminal printing can interfere with timing. So disable it.
                  with ui.configoverride({(b'progress', b'disable'): True}):
                      timer(d)
                  fm.end()
              @command(b'perf::dirs|perfdirs', formatteropts)
              def perfdirs(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  dirstate = repo.dirstate
                  b'a' in dirstate
                  def d():
                      dirstate.hasdir(b'a')
                      try:
                          del dirstate._map._dirs
                      except AttributeError:
                          pass
                  timer(d)
                  fm.end()
              @command(
                  b'perf::dirstate|perfdirstate',
                  [
                      (
                          b'',
                          b'iteration',
                          None,
                          b'benchmark a full iteration for the dirstate',
                      ),
                      (
                          b'',
                          b'contains',
                          None,
                          b'benchmark a large amount of `nf in dirstate` calls',
                      ),
                  ]
                  + formatteropts,
              )
              def perfdirstate(ui, repo, **opts):
                  """benchmap the time of various distate operations
                  By default benchmark the time necessary to load a dirstate from scratch.
                  The dirstate is loaded to the point were a "contains" request can be
                  answered.
                  """
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  b"a" in repo.dirstate
                  if opts[b'iteration'] and opts[b'contains']:
                      msg = b'only specify one of --iteration or --contains'
                      raise error.Abort(msg)
                  if opts[b'iteration']:
                      setup = None
                      dirstate = repo.dirstate
                      def d():
                          for f in dirstate:
                              pass
                  elif opts[b'contains']:
                      setup = None
                      dirstate = repo.dirstate
                      allfiles = list(dirstate)
                      # also add file path that will be "missing" from the dirstate
                      allfiles.extend([f[::-1] for f in allfiles])
                      def d():
                          for f in allfiles:
                              f in dirstate
                  else:
                      def setup():
                          repo.dirstate.invalidate()
                      def d():
                          b"a" in repo.dirstate
                  timer(d, setup=setup)
                  fm.end()
              @command(b'perf::dirstatedirs|perfdirstatedirs', formatteropts)
              def perfdirstatedirs(ui, repo, **opts):
                  """benchmap a 'dirstate.hasdir' call from an empty `dirs` cache"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  repo.dirstate.hasdir(b"a")
                  def setup():
                      try:
                          del repo.dirstate._map._dirs
                      except AttributeError:
                          pass
                  def d():
                      repo.dirstate.hasdir(b"a")
                  timer(d, setup=setup)
                  fm.end()
              @command(b'perf::dirstatefoldmap|perfdirstatefoldmap', formatteropts)
              def perfdirstatefoldmap(ui, repo, **opts):
                  """benchmap a `dirstate._map.filefoldmap.get()` request
                  The dirstate filefoldmap cache is dropped between every request.
                  """
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  dirstate = repo.dirstate
                  dirstate._map.filefoldmap.get(b'a')
                  def setup():
                      del dirstate._map.filefoldmap
                  def d():
                      dirstate._map.filefoldmap.get(b'a')
                  timer(d, setup=setup)
                  fm.end()
              @command(b'perf::dirfoldmap|perfdirfoldmap', formatteropts)
              def perfdirfoldmap(ui, repo, **opts):
                  """benchmap a `dirstate._map.dirfoldmap.get()` request
                  The dirstate dirfoldmap cache is dropped between every request.
                  """
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  dirstate = repo.dirstate
                  dirstate._map.dirfoldmap.get(b'a')
                  def setup():
                      del dirstate._map.dirfoldmap
                      try:
                          del dirstate._map._dirs
                      except AttributeError:
                          pass
                  def d():
                      dirstate._map.dirfoldmap.get(b'a')
                  timer(d, setup=setup)
                  fm.end()
              @command(b'perf::dirstatewrite|perfdirstatewrite', formatteropts)
              def perfdirstatewrite(ui, repo, **opts):
                  """benchmap the time it take to write a dirstate on disk"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  ds = repo.dirstate
                  b"a" in ds
                  def setup():
                      ds._dirty = True
                  def d():
                      ds.write(repo.currenttransaction())
                  with repo.wlock():
                      timer(d, setup=setup)
                  fm.end()
              def _getmergerevs(repo, opts):
                  """parse command argument to return rev involved in merge
                  input: options dictionnary with `rev`, `from` and `bse`
                  output: (localctx, otherctx, basectx)
                  """
                  if opts[b'from']:
                      fromrev = scmutil.revsingle(repo, opts[b'from'])
                      wctx = repo[fromrev]
                  else:
                      wctx = repo[None]
                      # we don't want working dir files to be stat'd in the benchmark, so
                      # prime that cache
                      wctx.dirty()
                  rctx = scmutil.revsingle(repo, opts[b'rev'], opts[b'rev'])
                  if opts[b'base']:
                      fromrev = scmutil.revsingle(repo, opts[b'base'])
                      ancestor = repo[fromrev]
                  else:
                      ancestor = wctx.ancestor(rctx)
                  return (wctx, rctx, ancestor)
              @command(
                  b'perf::mergecalculate|perfmergecalculate',
                  [
                      (b'r', b'rev', b'.', b'rev to merge against'),
                      (b'', b'from', b'', b'rev to merge from'),
                      (b'', b'base', b'', b'the revision to use as base'),
                  ]
                  + formatteropts,
              )
              def perfmergecalculate(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  wctx, rctx, ancestor = _getmergerevs(repo, opts)
                  def d():
                      # acceptremote is True because we don't want prompts in the middle of
                      # our benchmark
                      merge.calculateupdates(
                          repo,
                          wctx,
                          rctx,
                          [ancestor],
                          branchmerge=False,
                          force=False,
                          acceptremote=True,
                          followcopies=True,
                      )
                  timer(d)
                  fm.end()
              @command(
                  b'perf::mergecopies|perfmergecopies',
                  [
                      (b'r', b'rev', b'.', b'rev to merge against'),
                      (b'', b'from', b'', b'rev to merge from'),
                      (b'', b'base', b'', b'the revision to use as base'),
                  ]
                  + formatteropts,
              )
              def perfmergecopies(ui, repo, **opts):
                  """measure runtime of `copies.mergecopies`"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  wctx, rctx, ancestor = _getmergerevs(repo, opts)
                  def d():
                      # acceptremote is True because we don't want prompts in the middle of
                      # our benchmark
                      copies.mergecopies(repo, wctx, rctx, ancestor)
                  timer(d)
                  fm.end()
              @command(b'perf::pathcopies|perfpathcopies', [], b"REV REV")
              def perfpathcopies(ui, repo, rev1, rev2, **opts):
                  """benchmark the copy tracing logic"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  ctx1 = scmutil.revsingle(repo, rev1, rev1)
                  ctx2 = scmutil.revsingle(repo, rev2, rev2)
                  def d():
                      copies.pathcopies(ctx1, ctx2)
                  timer(d)
                  fm.end()
              @command(
                  b'perf::phases|perfphases',
                  [
                      (b'', b'full', False, b'include file reading time too'),
                  ],
                  b"",
              )
              def perfphases(ui, repo, **opts):
                  """benchmark phasesets computation"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  _phases = repo._phasecache
                  full = opts.get(b'full')
                  def d():
                      phases = _phases
                      if full:
                          clearfilecache(repo, b'_phasecache')
                          phases = repo._phasecache
                      phases.invalidate()
                      phases.loadphaserevs(repo)
                  timer(d)
                  fm.end()
              @command(b'perf::phasesremote|perfphasesremote', [], b"[DEST]")
              def perfphasesremote(ui, repo, dest=None, **opts):
                  """benchmark time needed to analyse phases of the remote server"""
                  from mercurial.node import bin
                  from mercurial import (
                      exchange,
                      hg,
                      phases,
                  )
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  path = ui.getpath(dest, default=(b'default-push', b'default'))
                  if not path:
                      raise error.Abort(
                          b'default repository not configured!',
                          hint=b"see 'hg help config.paths'",
                      )
                  if util.safehasattr(path, 'main_path'):
                      path = path.get_push_variant()
                      dest = path.loc
                  else:
                      dest = path.pushloc or path.loc
                  ui.statusnoi18n(b'analysing phase of %s\n' % util.hidepassword(dest))
                  other = hg.peer(repo, opts, dest)
                  # easier to perform discovery through the operation
                  op = exchange.pushoperation(repo, other)
                  exchange._pushdiscoverychangeset(op)
                  remotesubset = op.fallbackheads
                  with other.commandexecutor() as e:
                      remotephases = e.callcommand(
                          b'listkeys', {b'namespace': b'phases'}
                      ).result()
                  del other
                  publishing = remotephases.get(b'publishing', False)
                  if publishing:
                      ui.statusnoi18n(b'publishing: yes\n')
                  else:
                      ui.statusnoi18n(b'publishing: no\n')
                  has_node = getattr(repo.changelog.index, 'has_node', None)
                  if has_node is None:
                      has_node = repo.changelog.nodemap.__contains__
                  nonpublishroots = 0
                  for nhex, phase in remotephases.iteritems():
                      if nhex == b'publishing':  # ignore data related to publish option
                          continue
                      node = bin(nhex)
                      if has_node(node) and int(phase):
                          nonpublishroots += 1
                  ui.statusnoi18n(b'number of roots: %d\n' % len(remotephases))
                  ui.statusnoi18n(b'number of known non public roots: %d\n' % nonpublishroots)
                  def d():
                      phases.remotephasessummary(repo, remotesubset, remotephases)
                  timer(d)
                  fm.end()
              @command(
                  b'perf::manifest|perfmanifest',
                  [
                      (b'm', b'manifest-rev', False, b'Look up a manifest node revision'),
                      (b'', b'clear-disk', False, b'clear on-disk caches too'),
                  ]
                  + formatteropts,
                  b'REV|NODE',
              )
              def perfmanifest(ui, repo, rev, manifest_rev=False, clear_disk=False, **opts):
                  """benchmark the time to read a manifest from disk and return a usable
                  dict-like object
                  Manifest caches are cleared before retrieval."""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  if not manifest_rev:
                      ctx = scmutil.revsingle(repo, rev, rev)
                      t = ctx.manifestnode()
                  else:
                      from mercurial.node import bin
                      if len(rev) == 40:
                          t = bin(rev)
                      else:
                          try:
                              rev = int(rev)
                              if util.safehasattr(repo.manifestlog, b'getstorage'):
                                  t = repo.manifestlog.getstorage(b'').node(rev)
                              else:
                                  t = repo.manifestlog._revlog.lookup(rev)
                          except ValueError:
                              raise error.Abort(
                                  b'manifest revision must be integer or full node'
                              )
                  def d():
                      repo.manifestlog.clearcaches(clear_persisted_data=clear_disk)
                      repo.manifestlog[t].read()
                  timer(d)
                  fm.end()
              @command(b'perf::changeset|perfchangeset', formatteropts)
              def perfchangeset(ui, repo, rev, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  n = scmutil.revsingle(repo, rev).node()
                  def d():
                      repo.changelog.read(n)
                      # repo.changelog._cache = None
                  timer(d)
                  fm.end()
              @command(b'perf::ignore|perfignore', formatteropts)
              def perfignore(ui, repo, **opts):
                  """benchmark operation related to computing ignore"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  dirstate = repo.dirstate
                  def setupone():
                      dirstate.invalidate()
                      clearfilecache(dirstate, b'_ignore')
                  def runone():
                      dirstate._ignore
                  timer(runone, setup=setupone, title=b"load")
                  fm.end()
              @command(
                  b'perf::index|perfindex',
                  [
                      (b'', b'rev', [], b'revision to be looked up (default tip)'),
                      (b'', b'no-lookup', None, b'do not revision lookup post creation'),
                  ]
                  + formatteropts,
              )
              def perfindex(ui, repo, **opts):
                  """benchmark index creation time followed by a lookup
                  The default is to look `tip` up. Depending on the index implementation,
                  the revision looked up can matters. For example, an implementation
                  scanning the index will have a faster lookup time for `--rev tip` than for
                  `--rev 0`. The number of looked up revisions and their order can also
                  matters.
                  Example of useful set to test:
                  * tip
                  * 0
                  * -10:
                  * :10
                  * -10: + :10
                  * :10: + -10:
                  * -10000:
                  * -10000: + 0
                  It is not currently possible to check for lookup of a missing node. For
                  deeper lookup benchmarking, checkout the `perfnodemap` command."""
                  import mercurial.revlog
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  mercurial.revlog._prereadsize = 2 ** 24  # disable lazy parser in old hg
                  if opts[b'no_lookup']:
                      if opts['rev']:
                          raise error.Abort('--no-lookup and --rev are mutually exclusive')
                      nodes = []
                  elif not opts[b'rev']:
                      nodes = [repo[b"tip"].node()]
                  else:
                      revs = scmutil.revrange(repo, opts[b'rev'])
                      cl = repo.changelog
                      nodes = [cl.node(r) for r in revs]
                  unfi = repo.unfiltered()
                  # find the filecache func directly
                  # This avoid polluting the benchmark with the filecache logic
                  makecl = unfi.__class__.changelog.func
                  def setup():
                      # probably not necessary, but for good measure
                      clearchangelog(unfi)
                  def d():
                      cl = makecl(unfi)
                      for n in nodes:
                          cl.rev(n)
                  timer(d, setup=setup)
                  fm.end()
              @command(
                  b'perf::nodemap|perfnodemap',
                  [
                      (b'', b'rev', [], b'revision to be looked up (default tip)'),
                      (b'', b'clear-caches', True, b'clear revlog cache between calls'),
                  ]
                  + formatteropts,
              )
              def perfnodemap(ui, repo, **opts):
                  """benchmark the time necessary to look up revision from a cold nodemap
                  Depending on the implementation, the amount and order of revision we look
                  up can varies. Example of useful set to test:
                  * tip
                  * 0
                  * -10:
                  * :10
                  * -10: + :10
                  * :10: + -10:
                  * -10000:
                  * -10000: + 0
                  The command currently focus on valid binary lookup. Benchmarking for
                  hexlookup, prefix lookup and missing lookup would also be valuable.
                  """
                  import mercurial.revlog
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  mercurial.revlog._prereadsize = 2 ** 24  # disable lazy parser in old hg
                  unfi = repo.unfiltered()
                  clearcaches = opts[b'clear_caches']
                  # find the filecache func directly
                  # This avoid polluting the benchmark with the filecache logic
                  makecl = unfi.__class__.changelog.func
                  if not opts[b'rev']:
                      raise error.Abort(b'use --rev to specify revisions to look up')
                  revs = scmutil.revrange(repo, opts[b'rev'])
                  cl = repo.changelog
                  nodes = [cl.node(r) for r in revs]
                  # use a list to pass reference to a nodemap from one closure to the next
                  nodeget = [None]
                  def setnodeget():
                      # probably not necessary, but for good measure
                      clearchangelog(unfi)
                      cl = makecl(unfi)
                      if util.safehasattr(cl.index, 'get_rev'):
                          nodeget[0] = cl.index.get_rev
                      else:
                          nodeget[0] = cl.nodemap.get
                  def d():
                      get = nodeget[0]
                      for n in nodes:
                          get(n)
                  setup = None
                  if clearcaches:
                      def setup():
                          setnodeget()
                  else:
                      setnodeget()
                      d()  # prewarm the data structure
                  timer(d, setup=setup)
                  fm.end()
              @command(b'perf::startup|perfstartup', formatteropts)
              def perfstartup(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  def d():
                      if os.name != 'nt':
                          os.system(
                              b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0])
                          )
                      else:
                          os.environ['HGRCPATH'] = r' '
                          os.system("%s version -q > NUL" % sys.argv[0])
                  timer(d)
                  fm.end()
              def _find_stream_generator(version):
                  """find the proper generator function for this stream version"""
                  import mercurial.streamclone
                  available = {}
                  # try to fetch a v1 generator
                  generatev1 = getattr(mercurial.streamclone, "generatev1", None)
                  if generatev1 is not None:
                      def generate(repo):
                          entries, bytes, data = generatev2(repo, None, None, True)
                          return data
                      available[b'v1'] = generatev1
                  # try to fetch a v2 generator
                  generatev2 = getattr(mercurial.streamclone, "generatev2", None)
                  if generatev2 is not None:
                      def generate(repo):
                          entries, bytes, data = generatev2(repo, None, None, True)
                          return data
                      available[b'v2'] = generate
                  # try to fetch a v3 generator
                  generatev3 = getattr(mercurial.streamclone, "generatev3", None)
                  if generatev3 is not None:
                      def generate(repo):
                          entries, bytes, data = generatev3(repo, None, None, True)
                          return data
                      available[b'v3-exp'] = generate
                  # resolve the request
                  if version == b"latest":
                      # latest is the highest non experimental version
                      latest_key = max(v for v in available if b'-exp' not in v)
                      return available[latest_key]
                  elif version in available:
                      return available[version]
                  else:
                      msg = b"unkown or unavailable version: %s"
                      msg %= version
                      hint = b"available versions: %s"
                      hint %= b', '.join(sorted(available))
                      raise error.Abort(msg, hint=hint)
              @command(
                  b'perf::stream-locked-section',
                  [
                      (
                          b'',
                          b'stream-version',
                          b'latest',
                          b'stream version to use ("v1", "v2", "v3" or "latest", (the default))',
                      ),
                  ]
                  + formatteropts,
              )
              def perf_stream_clone_scan(ui, repo, stream_version, **opts):
                  """benchmark the initial, repo-locked, section of a stream-clone"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  # deletion of the generator may trigger some cleanup that we do not want to
                  # measure
                  result_holder = [None]
                  def setupone():
                      result_holder[0] = None
                  generate = _find_stream_generator(stream_version)
                  def runone():
                      # the lock is held for the duration the initialisation
                      result_holder[0] = generate(repo)
                  timer(runone, setup=setupone, title=b"load")
                  fm.end()
              @command(
                  b'perf::stream-generate',
                  [
                      (
                          b'',
                          b'stream-version',
                          b'latest',
                          b'stream version to us ("v1", "v2" or "latest", (the default))',
                      ),
                  ]
                  + formatteropts,
              )
              def perf_stream_clone_generate(ui, repo, stream_version, **opts):
                  """benchmark the full generation of a stream clone"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  # deletion of the generator may trigger some cleanup that we do not want to
                  # measure
                  generate = _find_stream_generator(stream_version)
                  def runone():
                      # the lock is held for the duration the initialisation
                      for chunk in generate(repo):
                          pass
                  timer(runone, title=b"generate")
                  fm.end()
              @command(
                  b'perf::stream-consume',
                  formatteropts,
              )
              def perf_stream_clone_consume(ui, repo, filename, **opts):
                  """benchmark the full application of a stream clone
                  This include the creation of the repository
                  """
                  # try except to appease check code
                  msg = b"mercurial too old, missing necessary module: %s"
                  try:
                      from mercurial import bundle2
                  except ImportError as exc:
                      msg %= _bytestr(exc)
                      raise error.Abort(msg)
                  try:
                      from mercurial import exchange
                  except ImportError as exc:
                      msg %= _bytestr(exc)
                      raise error.Abort(msg)
                  try:
                      from mercurial import hg
                  except ImportError as exc:
                      msg %= _bytestr(exc)
                      raise error.Abort(msg)
                  try:
                      from mercurial import localrepo
                  except ImportError as exc:
                      msg %= _bytestr(exc)
                      raise error.Abort(msg)
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  # deletion of the generator may trigger some cleanup that we do not want to
                  # measure
                  if not (os.path.isfile(filename) and os.access(filename, os.R_OK)):
                      raise error.Abort("not a readable file: %s" % filename)
                  run_variables = [None, None]
                  @contextlib.contextmanager
                  def context():
                      with open(filename, mode='rb') as bundle:
                          with tempfile.TemporaryDirectory() as tmp_dir:
                              tmp_dir = fsencode(tmp_dir)
                              run_variables[0] = bundle
                              run_variables[1] = tmp_dir
                              yield
                              run_variables[0] = None
                              run_variables[1] = None
                  def runone():
                      bundle = run_variables[0]
                      tmp_dir = run_variables[1]
                      # only pass ui when no srcrepo
                      localrepo.createrepository(
                          repo.ui, tmp_dir, requirements=repo.requirements
                      )
                      target = hg.repository(repo.ui, tmp_dir)
                      gen = exchange.readbundle(target.ui, bundle, bundle.name)
                      # stream v1
                      if util.safehasattr(gen, 'apply'):
                          gen.apply(target)
                      else:
                          with target.transaction(b"perf::stream-consume") as tr:
                              bundle2.applybundle(
                                  target,
                                  gen,
                                  tr,
                                  source=b'unbundle',
                                  url=filename,
                              )
                  timer(runone, context=context, title=b"consume")
                  fm.end()
              @command(b'perf::parents|perfparents', formatteropts)
              def perfparents(ui, repo, **opts):
                  """benchmark the time necessary to fetch one changeset's parents.
                  The fetch is done using the `node identifier`, traversing all object layers
                  from the repository object. The first N revisions will be used for this
                  benchmark. N is controlled by the ``perf.parentscount`` config option
                  (default: 1000).
                  """
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  # control the number of commits perfparents iterates over
                  # experimental config: perf.parentscount
                  count = getint(ui, b"perf", b"parentscount", 1000)
                  if len(repo.changelog) < count:
                      raise error.Abort(b"repo needs %d commits for this test" % count)
                  repo = repo.unfiltered()
                  nl = [repo.changelog.node(i) for i in _xrange(count)]
                  def d():
                      for n in nl:
                          repo.changelog.parents(n)
                  timer(d)
                  fm.end()
              @command(b'perf::ctxfiles|perfctxfiles', formatteropts)
              def perfctxfiles(ui, repo, x, **opts):
                  opts = _byteskwargs(opts)
                  x = int(x)
                  timer, fm = gettimer(ui, opts)
                  def d():
                      len(repo[x].files())
                  timer(d)
                  fm.end()
              @command(b'perf::rawfiles|perfrawfiles', formatteropts)
              def perfrawfiles(ui, repo, x, **opts):
                  opts = _byteskwargs(opts)
                  x = int(x)
                  timer, fm = gettimer(ui, opts)
                  cl = repo.changelog
                  def d():
                      len(cl.read(x)[3])
                  timer(d)
                  fm.end()
              @command(b'perf::lookup|perflookup', formatteropts)
              def perflookup(ui, repo, rev, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  timer(lambda: len(repo.lookup(rev)))
                  fm.end()
              @command(
                  b'perf::linelogedits|perflinelogedits',
                  [
                      (b'n', b'edits', 10000, b'number of edits'),
                      (b'', b'max-hunk-lines', 10, b'max lines in a hunk'),
                  ],
                  norepo=True,
              )
              def perflinelogedits(ui, **opts):
                  from mercurial import linelog
                  opts = _byteskwargs(opts)
                  edits = opts[b'edits']
                  maxhunklines = opts[b'max_hunk_lines']
                  maxb1 = 100000
                  random.seed(0)
                  randint = random.randint
                  currentlines = 0
                  arglist = []
                  for rev in _xrange(edits):
                      a1 = randint(0, currentlines)
                      a2 = randint(a1, min(currentlines, a1 + maxhunklines))
                      b1 = randint(0, maxb1)
                      b2 = randint(b1, b1 + maxhunklines)
                      currentlines += (b2 - b1) - (a2 - a1)
                      arglist.append((rev, a1, a2, b1, b2))
                  def d():
                      ll = linelog.linelog()
                      for args in arglist:
                          ll.replacelines(*args)
                  timer, fm = gettimer(ui, opts)
                  timer(d)
                  fm.end()
              @command(b'perf::revrange|perfrevrange', formatteropts)
              def perfrevrange(ui, repo, *specs, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  revrange = scmutil.revrange
                  timer(lambda: len(revrange(repo, specs)))
                  fm.end()
              @command(b'perf::nodelookup|perfnodelookup', formatteropts)
              def perfnodelookup(ui, repo, rev, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  import mercurial.revlog
                  mercurial.revlog._prereadsize = 2 ** 24  # disable lazy parser in old hg
                  n = scmutil.revsingle(repo, rev).node()
                  try:
                      cl = revlog(getsvfs(repo), radix=b"00changelog")
                  except TypeError:
                      cl = revlog(getsvfs(repo), indexfile=b"00changelog.i")
                  def d():
                      cl.rev(n)
                      clearcaches(cl)
                  timer(d)
                  fm.end()
              @command(
                  b'perf::log|perflog',
                  [(b'', b'rename', False, b'ask log to follow renames')] + formatteropts,
              )
              def perflog(ui, repo, rev=None, **opts):
                  opts = _byteskwargs(opts)
                  if rev is None:
                      rev = []
                  timer, fm = gettimer(ui, opts)
                  ui.pushbuffer()
                  timer(
                      lambda: commands.log(
                          ui, repo, rev=rev, date=b'', user=b'', copies=opts.get(b'rename')
                      )
                  )
                  ui.popbuffer()
                  fm.end()
              @command(b'perf::moonwalk|perfmoonwalk', formatteropts)
              def perfmoonwalk(ui, repo, **opts):
                  """benchmark walking the changelog backwards
                  This also loads the changelog data for each revision in the changelog.
                  """
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  def moonwalk():
                      for i in repo.changelog.revs(start=(len(repo) - 1), stop=-1):
                          ctx = repo[i]
                          ctx.branch()  # read changelog data (in addition to the index)
                  timer(moonwalk)
                  fm.end()
              @command(
                  b'perf::templating|perftemplating',
                  [
                      (b'r', b'rev', [], b'revisions to run the template on'),
                  ]
                  + formatteropts,
              )
              def perftemplating(ui, repo, testedtemplate=None, **opts):
                  """test the rendering time of a given template"""
                  if makelogtemplater is None:
                      raise error.Abort(
                          b"perftemplating not available with this Mercurial",
                          hint=b"use 4.3 or later",
                      )
                  opts = _byteskwargs(opts)
                  nullui = ui.copy()
                  nullui.fout = open(os.devnull, 'wb')
                  nullui.disablepager()
                  revs = opts.get(b'rev')
                  if not revs:
                      revs = [b'all()']
                  revs = list(scmutil.revrange(repo, revs))
                  defaulttemplate = (
                      b'{date|shortdate} [{rev}:{node|short}]'
                      b' {author|person}: {desc|firstline}\n'
                  )
                  if testedtemplate is None:
                      testedtemplate = defaulttemplate
                  displayer = makelogtemplater(nullui, repo, testedtemplate)
                  def format():
                      for r in revs:
                          ctx = repo[r]
                          displayer.show(ctx)
                          displayer.flush(ctx)
                  timer, fm = gettimer(ui, opts)
                  timer(format)
                  fm.end()
              def _displaystats(ui, opts, entries, data):
                  # use a second formatter because the data are quite different, not sure
                  # how it flies with the templater.
                  fm = ui.formatter(b'perf-stats', opts)
                  for key, title in entries:
                      values = data[key]
                      nbvalues = len(data)
                      values.sort()
                      stats = {
                          'key': key,
                          'title': title,
                          'nbitems': len(values),
                          'min': values[0][0],
                          '10%': values[(nbvalues * 10) // 100][0],
                          '25%': values[(nbvalues * 25) // 100][0],
                          '50%': values[(nbvalues * 50) // 100][0],
                          '75%': values[(nbvalues * 75) // 100][0],
                          '80%': values[(nbvalues * 80) // 100][0],
                          '85%': values[(nbvalues * 85) // 100][0],
                          '90%': values[(nbvalues * 90) // 100][0],
                          '95%': values[(nbvalues * 95) // 100][0],
                          '99%': values[(nbvalues * 99) // 100][0],
                          'max': values[-1][0],
                      }
                      fm.startitem()
                      fm.data(**stats)
                      # make node pretty for the human output
                      fm.plain('### %s (%d items)\n' % (title, len(values)))
                      lines = [
                          'min',
                          '10%',
                          '25%',
                          '50%',
                          '75%',
                          '80%',
                          '85%',
                          '90%',
                          '95%',
                          '99%',
                          'max',
                      ]
                      for l in lines:
                          fm.plain('%s: %s\n' % (l, stats[l]))
                  fm.end()
              @command(
                  b'perf::helper-mergecopies|perfhelper-mergecopies',
                  formatteropts
                  + [
                      (b'r', b'revs', [], b'restrict search to these revisions'),
                      (b'', b'timing', False, b'provides extra data (costly)'),
                      (b'', b'stats', False, b'provides statistic about the measured data'),
                  ],
              )
              def perfhelpermergecopies(ui, repo, revs=[], **opts):
                  """find statistics about potential parameters for `perfmergecopies`
                  This command find (base, p1, p2) triplet relevant for copytracing
                  benchmarking in the context of a merge.  It reports values for some of the
                  parameters that impact merge copy tracing time during merge.
                  If `--timing` is set, rename detection is run and the associated timing
                  will be reported. The extra details come at the cost of slower command
                  execution.
                  Since rename detection is only run once, other factors might easily
                  affect the precision of the timing. However it should give a good
                  approximation of which revision triplets are very costly.
                  """
                  opts = _byteskwargs(opts)
                  fm = ui.formatter(b'perf', opts)
                  dotiming = opts[b'timing']
                  dostats = opts[b'stats']
                  output_template = [
                      ("base", "%(base)12s"),
                      ("p1", "%(p1.node)12s"),
                      ("p2", "%(p2.node)12s"),
                      ("p1.nb-revs", "%(p1.nbrevs)12d"),
                      ("p1.nb-files", "%(p1.nbmissingfiles)12d"),
                      ("p1.renames", "%(p1.renamedfiles)12d"),
                      ("p1.time", "%(p1.time)12.3f"),
                      ("p2.nb-revs", "%(p2.nbrevs)12d"),
                      ("p2.nb-files", "%(p2.nbmissingfiles)12d"),
                      ("p2.renames", "%(p2.renamedfiles)12d"),
                      ("p2.time", "%(p2.time)12.3f"),
                      ("renames", "%(nbrenamedfiles)12d"),
                      ("total.time", "%(time)12.3f"),
                  ]
                  if not dotiming:
                      output_template = [
                          i
                          for i in output_template
                          if not ('time' in i[0] or 'renames' in i[0])
                      ]
                  header_names = [h for (h, v) in output_template]
                  output = ' '.join([v for (h, v) in output_template]) + '\n'
                  header = ' '.join(['%12s'] * len(header_names)) + '\n'
                  fm.plain(header % tuple(header_names))
                  if not revs:
                      revs = ['all()']
                  revs = scmutil.revrange(repo, revs)
                  if dostats:
                      alldata = {
                          'nbrevs': [],
                          'nbmissingfiles': [],
                      }
                      if dotiming:
                          alldata['parentnbrenames'] = []
                          alldata['totalnbrenames'] = []
                          alldata['parenttime'] = []
                          alldata['totaltime'] = []
                  roi = repo.revs('merge() and %ld', revs)
                  for r in roi:
                      ctx = repo[r]
                      p1 = ctx.p1()
                      p2 = ctx.p2()
                      bases = repo.changelog._commonancestorsheads(p1.rev(), p2.rev())
                      for b in bases:
                          b = repo[b]
                          p1missing = copies._computeforwardmissing(b, p1)
                          p2missing = copies._computeforwardmissing(b, p2)
                          data = {
                              b'base': b.hex(),
                              b'p1.node': p1.hex(),
                              b'p1.nbrevs': len(repo.revs('only(%d, %d)', p1.rev(), b.rev())),
                              b'p1.nbmissingfiles': len(p1missing),
                              b'p2.node': p2.hex(),
                              b'p2.nbrevs': len(repo.revs('only(%d, %d)', p2.rev(), b.rev())),
                              b'p2.nbmissingfiles': len(p2missing),
                          }
                          if dostats:
                              if p1missing:
                                  alldata['nbrevs'].append(
                                      (data['p1.nbrevs'], b.hex(), p1.hex())
                                  )
                                  alldata['nbmissingfiles'].append(
                                      (data['p1.nbmissingfiles'], b.hex(), p1.hex())
                                  )
                              if p2missing:
                                  alldata['nbrevs'].append(
                                      (data['p2.nbrevs'], b.hex(), p2.hex())
                                  )
                                  alldata['nbmissingfiles'].append(
                                      (data['p2.nbmissingfiles'], b.hex(), p2.hex())
                                  )
                          if dotiming:
                              begin = util.timer()
                              mergedata = copies.mergecopies(repo, p1, p2, b)
                              end = util.timer()
                              # not very stable timing since we did only one run
                              data['time'] = end - begin
                              # mergedata contains five dicts: "copy", "movewithdir",
                              # "diverge", "renamedelete" and "dirmove".
                              # The first 4 are about renamed file so lets count that.
                              renames = len(mergedata[0])
                              renames += len(mergedata[1])
                              renames += len(mergedata[2])
                              renames += len(mergedata[3])
                              data['nbrenamedfiles'] = renames
                              begin = util.timer()
                              p1renames = copies.pathcopies(b, p1)
                              end = util.timer()
                              data['p1.time'] = end - begin
                              begin = util.timer()
                              p2renames = copies.pathcopies(b, p2)
                              end = util.timer()
                              data['p2.time'] = end - begin
                              data['p1.renamedfiles'] = len(p1renames)
                              data['p2.renamedfiles'] = len(p2renames)
                              if dostats:
                                  if p1missing:
                                      alldata['parentnbrenames'].append(
                                          (data['p1.renamedfiles'], b.hex(), p1.hex())
                                      )
                                      alldata['parenttime'].append(
                                          (data['p1.time'], b.hex(), p1.hex())
                                      )
                                  if p2missing:
                                      alldata['parentnbrenames'].append(
                                          (data['p2.renamedfiles'], b.hex(), p2.hex())
                                      )
                                      alldata['parenttime'].append(
                                          (data['p2.time'], b.hex(), p2.hex())
                                      )
                                  if p1missing or p2missing:
                                      alldata['totalnbrenames'].append(
                                          (
                                              data['nbrenamedfiles'],
                                              b.hex(),
                                              p1.hex(),
                                              p2.hex(),
                                          )
                                      )
                                      alldata['totaltime'].append(
                                          (data['time'], b.hex(), p1.hex(), p2.hex())
                                      )
                          fm.startitem()
                          fm.data(**data)
                          # make node pretty for the human output
                          out = data.copy()
                          out['base'] = fm.hexfunc(b.node())
                          out['p1.node'] = fm.hexfunc(p1.node())
                          out['p2.node'] = fm.hexfunc(p2.node())
                          fm.plain(output % out)
                  fm.end()
                  if dostats:
                      # use a second formatter because the data are quite different, not sure
                      # how it flies with the templater.
                      entries = [
                          ('nbrevs', 'number of revision covered'),
                          ('nbmissingfiles', 'number of missing files at head'),
                      ]
                      if dotiming:
                          entries.append(
                              ('parentnbrenames', 'rename from one parent to base')
                          )
                          entries.append(('totalnbrenames', 'total number of renames'))
                          entries.append(('parenttime', 'time for one parent'))
                          entries.append(('totaltime', 'time for both parents'))
                      _displaystats(ui, opts, entries, alldata)
              @command(
                  b'perf::helper-pathcopies|perfhelper-pathcopies',
                  formatteropts
                  + [
                      (b'r', b'revs', [], b'restrict search to these revisions'),
                      (b'', b'timing', False, b'provides extra data (costly)'),
                      (b'', b'stats', False, b'provides statistic about the measured data'),
                  ],
              )
              def perfhelperpathcopies(ui, repo, revs=[], **opts):
                  """find statistic about potential parameters for the `perftracecopies`
                  This command find source-destination pair relevant for copytracing testing.
                  It report value for some of the parameters that impact copy tracing time.
                  If `--timing` is set, rename detection is run and the associated timing
                  will be reported. The extra details comes at the cost of a slower command
                  execution.
                  Since the rename detection is only run once, other factors might easily
                  affect the precision of the timing. However it should give a good
                  approximation of which revision pairs are very costly.
                  """
                  opts = _byteskwargs(opts)
                  fm = ui.formatter(b'perf', opts)
                  dotiming = opts[b'timing']
                  dostats = opts[b'stats']
                  if dotiming:
                      header = '%12s %12s %12s %12s %12s %12s\n'
                      output = (
                          "%(source)12s %(destination)12s "
                          "%(nbrevs)12d %(nbmissingfiles)12d "
                          "%(nbrenamedfiles)12d %(time)18.5f\n"
                      )
                      header_names = (
                          "source",
                          "destination",
                          "nb-revs",
                          "nb-files",
                          "nb-renames",
                          "time",
                      )
                      fm.plain(header % header_names)
                  else:
                      header = '%12s %12s %12s %12s\n'
                      output = (
                          "%(source)12s %(destination)12s "
                          "%(nbrevs)12d %(nbmissingfiles)12d\n"
                      )
                      fm.plain(header % ("source", "destination", "nb-revs", "nb-files"))
                  if not revs:
                      revs = ['all()']
                  revs = scmutil.revrange(repo, revs)
                  if dostats:
                      alldata = {
                          'nbrevs': [],
                          'nbmissingfiles': [],
                      }
                      if dotiming:
                          alldata['nbrenames'] = []
                          alldata['time'] = []
                  roi = repo.revs('merge() and %ld', revs)
                  for r in roi:
                      ctx = repo[r]
                      p1 = ctx.p1().rev()
                      p2 = ctx.p2().rev()
                      bases = repo.changelog._commonancestorsheads(p1, p2)
                      for p in (p1, p2):
                          for b in bases:
                              base = repo[b]
                              parent = repo[p]
                              missing = copies._computeforwardmissing(base, parent)
                              if not missing:
                                  continue
                              data = {
                                  b'source': base.hex(),
                                  b'destination': parent.hex(),
                                  b'nbrevs': len(repo.revs('only(%d, %d)', p, b)),
                                  b'nbmissingfiles': len(missing),
                              }
                              if dostats:
                                  alldata['nbrevs'].append(
                                      (
                                          data['nbrevs'],
                                          base.hex(),
                                          parent.hex(),
                                      )
                                  )
                                  alldata['nbmissingfiles'].append(
                                      (
                                          data['nbmissingfiles'],
                                          base.hex(),
                                          parent.hex(),
                                      )
                                  )
                              if dotiming:
                                  begin = util.timer()
                                  renames = copies.pathcopies(base, parent)
                                  end = util.timer()
                                  # not very stable timing since we did only one run
                                  data['time'] = end - begin
                                  data['nbrenamedfiles'] = len(renames)
                                  if dostats:
                                      alldata['time'].append(
                                          (
                                              data['time'],
                                              base.hex(),
                                              parent.hex(),
                                          )
                                      )
                                      alldata['nbrenames'].append(
                                          (
                                              data['nbrenamedfiles'],
                                              base.hex(),
                                              parent.hex(),
                                          )
                                      )
                              fm.startitem()
                              fm.data(**data)
                              out = data.copy()
                              out['source'] = fm.hexfunc(base.node())
                              out['destination'] = fm.hexfunc(parent.node())
                              fm.plain(output % out)
                  fm.end()
                  if dostats:
                      entries = [
                          ('nbrevs', 'number of revision covered'),
                          ('nbmissingfiles', 'number of missing files at head'),
                      ]
                      if dotiming:
                          entries.append(('nbrenames', 'renamed files'))
                          entries.append(('time', 'time'))
                      _displaystats(ui, opts, entries, alldata)
              @command(b'perf::cca|perfcca', formatteropts)
              def perfcca(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  timer(lambda: scmutil.casecollisionauditor(ui, False, repo.dirstate))
                  fm.end()
              @command(b'perf::fncacheload|perffncacheload', formatteropts)
              def perffncacheload(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  s = repo.store
                  def d():
                      s.fncache._load()
                  timer(d)
                  fm.end()
              @command(b'perf::fncachewrite|perffncachewrite', formatteropts)
              def perffncachewrite(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  s = repo.store
                  lock = repo.lock()
                  s.fncache._load()
                  tr = repo.transaction(b'perffncachewrite')
                  tr.addbackup(b'fncache')
                  def d():
                      s.fncache._dirty = True
                      s.fncache.write(tr)
                  timer(d)
                  tr.close()
                  lock.release()
                  fm.end()
              @command(b'perf::fncacheencode|perffncacheencode', formatteropts)
              def perffncacheencode(ui, repo, **opts):
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  s = repo.store
                  s.fncache._load()
                  def d():
                      for p in s.fncache.entries:
                          s.encode(p)
                  timer(d)
                  fm.end()
              def _bdiffworker(q, blocks, xdiff, ready, done):
                  while not done.is_set():
                      pair = q.get()
                      while pair is not None:
                          if xdiff:
                              mdiff.bdiff.xdiffblocks(*pair)
                          elif blocks:
                              mdiff.bdiff.blocks(*pair)
                          else:
                              mdiff.textdiff(*pair)
                          q.task_done()
                          pair = q.get()
                      q.task_done()  # for the None one
                      with ready:
                          ready.wait()
              def _manifestrevision(repo, mnode):
                  ml = repo.manifestlog
                  if util.safehasattr(ml, b'getstorage'):
                      store = ml.getstorage(b'')
                  else:
                      store = ml._revlog
                  return store.revision(mnode)
              @command(
                  b'perf::bdiff|perfbdiff',
                  revlogopts
                  + formatteropts
                  + [
                      (
                          b'',
                          b'count',
 ,
                          b'number of revisions to test (when using --startrev)',
                      ),
                      (b'', b'alldata', False, b'test bdiffs for all associated revisions'),
                      (b'', b'threads', 0, b'number of thread to use (disable with 0)'),
                      (b'', b'blocks', False, b'test computing diffs into blocks'),
                      (b'', b'xdiff', False, b'use xdiff algorithm'),
                  ],
                  b'-c|-m|FILE REV',
              )
              def perfbdiff(ui, repo, file_, rev=None, count=None, threads=0, **opts):
                  """benchmark a bdiff between revisions
                  By default, benchmark a bdiff between its delta parent and itself.
                  With ``--count``, benchmark bdiffs between delta parents and self for N
                  revisions starting at the specified revision.
                  With ``--alldata``, assume the requested revision is a changeset and
                  measure bdiffs for all changes related to that changeset (manifest
                  and filelogs).
                  """
                  opts = _byteskwargs(opts)
                  if opts[b'xdiff'] and not opts[b'blocks']:
                      raise error.CommandError(b'perfbdiff', b'--xdiff requires --blocks')
                  if opts[b'alldata']:
                      opts[b'changelog'] = True
                  if opts.get(b'changelog') or opts.get(b'manifest'):
                      file_, rev = None, file_
                  elif rev is None:
                      raise error.CommandError(b'perfbdiff', b'invalid arguments')
                  blocks = opts[b'blocks']
                  xdiff = opts[b'xdiff']
                  textpairs = []
                  r = cmdutil.openrevlog(repo, b'perfbdiff', file_, opts)
                  startrev = r.rev(r.lookup(rev))
                  for rev in range(startrev, min(startrev + count, len(r) - 1)):
                      if opts[b'alldata']:
                          # Load revisions associated with changeset.
                          ctx = repo[rev]
                          mtext = _manifestrevision(repo, ctx.manifestnode())
                          for pctx in ctx.parents():
                              pman = _manifestrevision(repo, pctx.manifestnode())
                              textpairs.append((pman, mtext))
                          # Load filelog revisions by iterating manifest delta.
                          man = ctx.manifest()
                          pman = ctx.p1().manifest()
                          for filename, change in pman.diff(man).items():
                              fctx = repo.file(filename)
                              f1 = fctx.revision(change[0][0] or -1)
                              f2 = fctx.revision(change[1][0] or -1)
                              textpairs.append((f1, f2))
                      else:
                          dp = r.deltaparent(rev)
                          textpairs.append((r.revision(dp), r.revision(rev)))
                  withthreads = threads > 0
                  if not withthreads:
                      def d():
                          for pair in textpairs:
                              if xdiff:
                                  mdiff.bdiff.xdiffblocks(*pair)
                              elif blocks:
                                  mdiff.bdiff.blocks(*pair)
                              else:
                                  mdiff.textdiff(*pair)
                  else:
                      q = queue()
                      for i in _xrange(threads):
                          q.put(None)
                      ready = threading.Condition()
                      done = threading.Event()
                      for i in _xrange(threads):
                          threading.Thread(
                              target=_bdiffworker, args=(q, blocks, xdiff, ready, done)
                          ).start()
                      q.join()
                      def d():
                          for pair in textpairs:
                              q.put(pair)
                          for i in _xrange(threads):
                              q.put(None)
                          with ready:
                              ready.notify_all()
                          q.join()
                  timer, fm = gettimer(ui, opts)
                  timer(d)
                  fm.end()
                  if withthreads:
                      done.set()
                      for i in _xrange(threads):
                          q.put(None)
                      with ready:
                          ready.notify_all()
              @command(
                  b'perf::unbundle',
                  formatteropts,
                  b'BUNDLE_FILE',
              )
              def perf_unbundle(ui, repo, fname, **opts):
                  """benchmark application of a bundle in a repository.
                  This does not include the final transaction processing"""
                  from mercurial import exchange
                  from mercurial import bundle2
                  from mercurial import transaction
                  opts = _byteskwargs(opts)
                  ###  some compatibility hotfix
                  #
                  # the data attribute is dropped in 63edc384d3b7 a changeset introducing a
                  # critical regression that break transaction rollback for files that are
                  # de-inlined.
                  method = transaction.transaction._addentry
                  pre_63edc384d3b7 = "data" in getargspec(method).args
                  # the `detailed_exit_code` attribute is introduced in 33c0c25d0b0f
                  # a changeset that is a close descendant of 18415fc918a1, the changeset
                  # that conclude the fix run for the bug introduced in 63edc384d3b7.
                  args = getargspec(error.Abort.__init__).args
                  post_18415fc918a1 = "detailed_exit_code" in args
                  old_max_inline = None
                  try:
                      if not (pre_63edc384d3b7 or post_18415fc918a1):
                          # disable inlining
                          old_max_inline = mercurial.revlog._maxinline
                          # large enough to never happen
                          mercurial.revlog._maxinline = 2 ** 50
                      with repo.lock():
                          bundle = [None, None]
                          orig_quiet = repo.ui.quiet
                          try:
                              repo.ui.quiet = True
                              with open(fname, mode="rb") as f:
                                  def noop_report(*args, **kwargs):
                                      pass
                                  def setup():
                                      gen, tr = bundle
                                      if tr is not None:
                                          tr.abort()
                                      bundle[:] = [None, None]
                                      f.seek(0)
                                      bundle[0] = exchange.readbundle(ui, f, fname)
                                      bundle[1] = repo.transaction(b'perf::unbundle')
                                      # silence the transaction
                                      bundle[1]._report = noop_report
                                  def apply():
                                      gen, tr = bundle
                                      bundle2.applybundle(
                                          repo,
                                          gen,
                                          tr,
                                          source=b'perf::unbundle',
                                          url=fname,
                                      )
                                  timer, fm = gettimer(ui, opts)
                                  timer(apply, setup=setup)
                                  fm.end()
                          finally:
                              repo.ui.quiet == orig_quiet
                              gen, tr = bundle
                              if tr is not None:
                                  tr.abort()
                  finally:
                      if old_max_inline is not None:
                          mercurial.revlog._maxinline = old_max_inline
              @command(
                  b'perf::unidiff|perfunidiff',
                  revlogopts
                  + formatteropts
                  + [
                      (
                          b'',
                          b'count',
 ,
                          b'number of revisions to test (when using --startrev)',
                      ),
                      (b'', b'alldata', False, b'test unidiffs for all associated revisions'),
                  ],
                  b'-c|-m|FILE REV',
              )
              def perfunidiff(ui, repo, file_, rev=None, count=None, **opts):
                  """benchmark a unified diff between revisions
                  This doesn't include any copy tracing - it's just a unified diff
                  of the texts.
                  By default, benchmark a diff between its delta parent and itself.
                  With ``--count``, benchmark diffs between delta parents and self for N
                  revisions starting at the specified revision.
                  With ``--alldata``, assume the requested revision is a changeset and
                  measure diffs for all changes related to that changeset (manifest
                  and filelogs).
                  """
                  opts = _byteskwargs(opts)
                  if opts[b'alldata']:
                      opts[b'changelog'] = True
                  if opts.get(b'changelog') or opts.get(b'manifest'):
                      file_, rev = None, file_
                  elif rev is None:
                      raise error.CommandError(b'perfunidiff', b'invalid arguments')
                  textpairs = []
                  r = cmdutil.openrevlog(repo, b'perfunidiff', file_, opts)
                  startrev = r.rev(r.lookup(rev))
                  for rev in range(startrev, min(startrev + count, len(r) - 1)):
                      if opts[b'alldata']:
                          # Load revisions associated with changeset.
                          ctx = repo[rev]
                          mtext = _manifestrevision(repo, ctx.manifestnode())
                          for pctx in ctx.parents():
                              pman = _manifestrevision(repo, pctx.manifestnode())
                              textpairs.append((pman, mtext))
                          # Load filelog revisions by iterating manifest delta.
                          man = ctx.manifest()
                          pman = ctx.p1().manifest()
                          for filename, change in pman.diff(man).items():
                              fctx = repo.file(filename)
                              f1 = fctx.revision(change[0][0] or -1)
                              f2 = fctx.revision(change[1][0] or -1)
                              textpairs.append((f1, f2))
                      else:
                          dp = r.deltaparent(rev)
                          textpairs.append((r.revision(dp), r.revision(rev)))
                  def d():
                      for left, right in textpairs:
                          # The date strings don't matter, so we pass empty strings.
                          headerlines, hunks = mdiff.unidiff(
                              left, b'', right, b'', b'left', b'right', binary=False
                          )
                          # consume iterators in roughly the way patch.py does
                          b'\n'.join(headerlines)
                          b''.join(sum((list(hlines) for hrange, hlines in hunks), []))
                  timer, fm = gettimer(ui, opts)
                  timer(d)
                  fm.end()
              @command(b'perf::diffwd|perfdiffwd', formatteropts)
              def perfdiffwd(ui, repo, **opts):
                  """Profile diff of working directory changes"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  options = {
                      'w': 'ignore_all_space',
                      'b': 'ignore_space_change',
                      'B': 'ignore_blank_lines',
                  }
                  for diffopt in ('', 'w', 'b', 'B', 'wB'):
                      opts = {options[c]: b'1' for c in diffopt}
                      def d():
                          ui.pushbuffer()
                          commands.diff(ui, repo, **opts)
                          ui.popbuffer()
                      diffopt = diffopt.encode('ascii')
                      title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none')
                      timer(d, title=title)
                  fm.end()
              @command(
                  b'perf::revlogindex|perfrevlogindex',
                  revlogopts + formatteropts,
                  b'-c|-m|FILE',
              )
              def perfrevlogindex(ui, repo, file_=None, **opts):
                  """Benchmark operations against a revlog index.
                  This tests constructing a revlog instance, reading index data,
                  parsing index data, and performing various operations related to
                  index data.
                  """
                  opts = _byteskwargs(opts)
                  rl = cmdutil.openrevlog(repo, b'perfrevlogindex', file_, opts)
                  opener = getattr(rl, 'opener')  # trick linter
                  # compat with hg <= 5.8
                  radix = getattr(rl, 'radix', None)
                  indexfile = getattr(rl, '_indexfile', None)
                  if indexfile is None:
                      # compatibility with <= hg-5.8
                      indexfile = getattr(rl, 'indexfile')
                  data = opener.read(indexfile)
                  header = struct.unpack(b'>I', data[0:4])[0]
                  version = header & 0xFFFF
                  if version == 1:
                      inline = header & (1 << 16)
                  else:
                      raise error.Abort(b'unsupported revlog version: %d' % version)
                  parse_index_v1 = getattr(mercurial.revlog, 'parse_index_v1', None)
                  if parse_index_v1 is None:
                      parse_index_v1 = mercurial.revlog.revlogio().parseindex
                  rllen = len(rl)
                  node0 = rl.node(0)
                  node25 = rl.node(rllen // 4)
                  node50 = rl.node(rllen // 2)
                  node75 = rl.node(rllen // 4 * 3)
                  node100 = rl.node(rllen - 1)
                  allrevs = range(rllen)
                  allrevsrev = list(reversed(allrevs))
                  allnodes = [rl.node(rev) for rev in range(rllen)]
                  allnodesrev = list(reversed(allnodes))
                  def constructor():
                      if radix is not None:
                          revlog(opener, radix=radix)
                      else:
                          # hg <= 5.8
                          revlog(opener, indexfile=indexfile)
                  def read():
                      with opener(indexfile) as fh:
                          fh.read()
                  def parseindex():
                      parse_index_v1(data, inline)
                  def getentry(revornode):
                      index = parse_index_v1(data, inline)[0]
                      index[revornode]
                  def getentries(revs, count=1):
                      index = parse_index_v1(data, inline)[0]
                      for i in range(count):
                          for rev in revs:
                              index[rev]
                  def resolvenode(node):
                      index = parse_index_v1(data, inline)[0]
                      rev = getattr(index, 'rev', None)
                      if rev is None:
                          nodemap = getattr(parse_index_v1(data, inline)[0], 'nodemap', None)
                          # This only works for the C code.
                          if nodemap is None:
                              return
                          rev = nodemap.__getitem__
                      try:
                          rev(node)
                      except error.RevlogError:
                          pass
                  def resolvenodes(nodes, count=1):
                      index = parse_index_v1(data, inline)[0]
                      rev = getattr(index, 'rev', None)
                      if rev is None:
                          nodemap = getattr(parse_index_v1(data, inline)[0], 'nodemap', None)
                          # This only works for the C code.
                          if nodemap is None:
                              return
                          rev = nodemap.__getitem__
                      for i in range(count):
                          for node in nodes:
                              try:
                                  rev(node)
                              except error.RevlogError:
                                  pass
                  benches = [
                      (constructor, b'revlog constructor'),
                      (read, b'read'),
                      (parseindex, b'create index object'),
                      (lambda: getentry(0), b'retrieve index entry for rev 0'),
                      (lambda: resolvenode(b'a' * 20), b'look up missing node'),
                      (lambda: resolvenode(node0), b'look up node at rev 0'),
                      (lambda: resolvenode(node25), b'look up node at 1/4 len'),
                      (lambda: resolvenode(node50), b'look up node at 1/2 len'),
                      (lambda: resolvenode(node75), b'look up node at 3/4 len'),
                      (lambda: resolvenode(node100), b'look up node at tip'),
                      # 2x variation is to measure caching impact.
                      (lambda: resolvenodes(allnodes), b'look up all nodes (forward)'),
                      (lambda: resolvenodes(allnodes, 2), b'look up all nodes 2x (forward)'),
                      (lambda: resolvenodes(allnodesrev), b'look up all nodes (reverse)'),
                      (
                          lambda: resolvenodes(allnodesrev, 2),
                          b'look up all nodes 2x (reverse)',
                      ),
                      (lambda: getentries(allrevs), b'retrieve all index entries (forward)'),
                      (
                          lambda: getentries(allrevs, 2),
                          b'retrieve all index entries 2x (forward)',
                      ),
                      (
                          lambda: getentries(allrevsrev),
                          b'retrieve all index entries (reverse)',
                      ),
                      (
                          lambda: getentries(allrevsrev, 2),
                          b'retrieve all index entries 2x (reverse)',
                      ),
                  ]
                  for fn, title in benches:
                      timer, fm = gettimer(ui, opts)
                      timer(fn, title=title)
                      fm.end()
              @command(
                  b'perf::revlogrevisions|perfrevlogrevisions',
                  revlogopts
                  + formatteropts
                  + [
                      (b'd', b'dist', 100, b'distance between the revisions'),
                      (b's', b'startrev', 0, b'revision to start reading at'),
                      (b'', b'reverse', False, b'read in reverse'),
                  ],
                  b'-c|-m|FILE',
              )
              def perfrevlogrevisions(
                  ui, repo, file_=None, startrev=0, reverse=False, **opts
              ):
                  """Benchmark reading a series of revisions from a revlog.
                  By default, we read every ``-d/--dist`` revision from 0 to tip of
                  the specified revlog.
                  The start revision can be defined via ``-s/--startrev``.
                  """
                  opts = _byteskwargs(opts)
                  rl = cmdutil.openrevlog(repo, b'perfrevlogrevisions', file_, opts)
                  rllen = getlen(ui)(rl)
                  if startrev < 0:
                      startrev = rllen + startrev
                  def d():
                      rl.clearcaches()
                      beginrev = startrev
                      endrev = rllen
                      dist = opts[b'dist']
                      if reverse:
                          beginrev, endrev = endrev - 1, beginrev - 1
                          dist = -1 * dist
                      for x in _xrange(beginrev, endrev, dist):
                          # Old revisions don't support passing int.
                          n = rl.node(x)
                          rl.revision(n)
                  timer, fm = gettimer(ui, opts)
                  timer(d)
                  fm.end()
              @command(
                  b'perf::revlogwrite|perfrevlogwrite',
                  revlogopts
                  + formatteropts
                  + [
                      (b's', b'startrev', 1000, b'revision to start writing at'),
                      (b'', b'stoprev', -1, b'last revision to write'),
                      (b'', b'count', 3, b'number of passes to perform'),
                      (b'', b'details', False, b'print timing for every revisions tested'),
                      (b'', b'source', b'full', b'the kind of data feed in the revlog'),
                      (b'', b'lazydeltabase', True, b'try the provided delta first'),
                      (b'', b'clear-caches', True, b'clear revlog cache between calls'),
                  ],
                  b'-c|-m|FILE',
              )
              def perfrevlogwrite(ui, repo, file_=None, startrev=1000, stoprev=-1, **opts):
                  """Benchmark writing a series of revisions to a revlog.
                  Possible source values are:
                  * `full`: add from a full text (default).
                  * `parent-1`: add from a delta to the first parent
                  * `parent-2`: add from a delta to the second parent if it exists
                                (use a delta from the first parent otherwise)
                  * `parent-smallest`: add from the smallest delta (either p1 or p2)
                  * `storage`: add from the existing precomputed deltas
                  Note: This performance command measures performance in a custom way. As a
                  result some of the global configuration of the 'perf' command does not
                  apply to it:
                  * ``pre-run``: disabled
                  * ``profile-benchmark``: disabled
                  * ``run-limits``: disabled use --count instead
                  """
                  opts = _byteskwargs(opts)
                  rl = cmdutil.openrevlog(repo, b'perfrevlogwrite', file_, opts)
                  rllen = getlen(ui)(rl)
                  if startrev < 0:
                      startrev = rllen + startrev
                  if stoprev < 0:
                      stoprev = rllen + stoprev
                  lazydeltabase = opts['lazydeltabase']
                  source = opts['source']
                  clearcaches = opts['clear_caches']
                  validsource = (
                      b'full',
                      b'parent-1',
                      b'parent-2',
                      b'parent-smallest',
                      b'storage',
                  )
                  if source not in validsource:
                      raise error.Abort('invalid source type: %s' % source)
                  ### actually gather results
                  count = opts['count']
                  if count <= 0:
                      raise error.Abort('invalide run count: %d' % count)
                  allresults = []
                  for c in range(count):
                      timing = _timeonewrite(
                          ui,
                          rl,
                          source,
                          startrev,
                          stoprev,
                          c + 1,
                          lazydeltabase=lazydeltabase,
                          clearcaches=clearcaches,
                      )
                      allresults.append(timing)
                  ### consolidate the results in a single list
                  results = []
                  for idx, (rev, t) in enumerate(allresults[0]):
                      ts = [t]
                      for other in allresults[1:]:
                          orev, ot = other[idx]
                          assert orev == rev
                          ts.append(ot)
                      results.append((rev, ts))
                  resultcount = len(results)
                  ### Compute and display relevant statistics
                  # get a formatter
                  fm = ui.formatter(b'perf', opts)
                  displayall = ui.configbool(b"perf", b"all-timing", True)
                  # print individual details if requested
                  if opts['details']:
                      for idx, item in enumerate(results, 1):
                          rev, data = item
                          title = 'revisions #%d of %d, rev %d' % (idx, resultcount, rev)
                          formatone(fm, data, title=title, displayall=displayall)
                  # sorts results by median time
                  results.sort(key=lambda x: sorted(x[1])[len(x[1]) // 2])
                  # list of (name, index) to display)
                  relevants = [
                      ("min", 0),
                      ("10%", resultcount * 10 // 100),
                      ("25%", resultcount * 25 // 100),
                      ("50%", resultcount * 70 // 100),
                      ("75%", resultcount * 75 // 100),
                      ("90%", resultcount * 90 // 100),
                      ("95%", resultcount * 95 // 100),
                      ("99%", resultcount * 99 // 100),
                      ("99.9%", resultcount * 999 // 1000),
                      ("99.99%", resultcount * 9999 // 10000),
                      ("99.999%", resultcount * 99999 // 100000),
                      ("max", -1),
                  ]
                  if not ui.quiet:
                      for name, idx in relevants:
                          data = results[idx]
                          title = '%s of %d, rev %d' % (name, resultcount, data[0])
                          formatone(fm, data[1], title=title, displayall=displayall)
                  # XXX summing that many float will not be very precise, we ignore this fact
                  # for now
                  totaltime = []
                  for item in allresults:
                      totaltime.append(
                          (
                              sum(x[1][0] for x in item),
                              sum(x[1][1] for x in item),
                              sum(x[1][2] for x in item),
                          )
                      )
                  formatone(
                      fm,
                      totaltime,
                      title="total time (%d revs)" % resultcount,
                      displayall=displayall,
                  )
                  fm.end()
              class _faketr:
                  def add(s, x, y, z=None):
                      return None
              def _timeonewrite(
                  ui,
                  orig,
                  source,
                  startrev,
                  stoprev,
                  runidx=None,
                  lazydeltabase=True,
                  clearcaches=True,
              ):
                  timings = []
                  tr = _faketr()
                  with _temprevlog(ui, orig, startrev) as dest:
                      dest._lazydeltabase = lazydeltabase
                      revs = list(orig.revs(startrev, stoprev))
                      total = len(revs)
                      topic = 'adding'
                      if runidx is not None:
                          topic += ' (run #%d)' % runidx
                      # Support both old and new progress API
                      if util.safehasattr(ui, 'makeprogress'):
                          progress = ui.makeprogress(topic, unit='revs', total=total)
                          def updateprogress(pos):
                              progress.update(pos)
                          def completeprogress():
                              progress.complete()
                      else:
                          def updateprogress(pos):
                              ui.progress(topic, pos, unit='revs', total=total)
                          def completeprogress():
                              ui.progress(topic, None, unit='revs', total=total)
                      for idx, rev in enumerate(revs):
                          updateprogress(idx)
                          addargs, addkwargs = _getrevisionseed(orig, rev, tr, source)
                          if clearcaches:
                              dest.index.clearcaches()
                              dest.clearcaches()
                          with timeone() as r:
                              dest.addrawrevision(*addargs, **addkwargs)
                          timings.append((rev, r[0]))
                      updateprogress(total)
                      completeprogress()
                  return timings
              def _getrevisionseed(orig, rev, tr, source):
                  from mercurial.node import nullid
                  linkrev = orig.linkrev(rev)
                  node = orig.node(rev)
                  p1, p2 = orig.parents(node)
                  flags = orig.flags(rev)
                  cachedelta = None
                  text = None
                  if source == b'full':
                      text = orig.revision(rev)
                  elif source == b'parent-1':
                      baserev = orig.rev(p1)
                      cachedelta = (baserev, orig.revdiff(p1, rev))
                  elif source == b'parent-2':
                      parent = p2
                      if p2 == nullid:
                          parent = p1
                      baserev = orig.rev(parent)
                      cachedelta = (baserev, orig.revdiff(parent, rev))
                  elif source == b'parent-smallest':
                      p1diff = orig.revdiff(p1, rev)
                      parent = p1
                      diff = p1diff
                      if p2 != nullid:
                          p2diff = orig.revdiff(p2, rev)
                          if len(p1diff) > len(p2diff):
                              parent = p2
                              diff = p2diff
                      baserev = orig.rev(parent)
                      cachedelta = (baserev, diff)
                  elif source == b'storage':
                      baserev = orig.deltaparent(rev)
                      cachedelta = (baserev, orig.revdiff(orig.node(baserev), rev))
                  return (
                      (text, tr, linkrev, p1, p2),
                      {'node': node, 'flags': flags, 'cachedelta': cachedelta},
                  )
              @contextlib.contextmanager
              def _temprevlog(ui, orig, truncaterev):
                  from mercurial import vfs as vfsmod
                  if orig._inline:
                      raise error.Abort('not supporting inline revlog (yet)')
                  revlogkwargs = {}
                  k = 'upperboundcomp'
                  if util.safehasattr(orig, k):
                      revlogkwargs[k] = getattr(orig, k)
                  indexfile = getattr(orig, '_indexfile', None)
                  if indexfile is None:
                      # compatibility with <= hg-5.8
                      indexfile = getattr(orig, 'indexfile')
                  origindexpath = orig.opener.join(indexfile)
                  datafile = getattr(orig, '_datafile', getattr(orig, 'datafile'))
                  origdatapath = orig.opener.join(datafile)
                  radix = b'revlog'
                  indexname = b'revlog.i'
                  dataname = b'revlog.d'
                  tmpdir = tempfile.mkdtemp(prefix='tmp-hgperf-')
                  try:
                      # copy the data file in a temporary directory
                      ui.debug('copying data in %s\n' % tmpdir)
                      destindexpath = os.path.join(tmpdir, 'revlog.i')
                      destdatapath = os.path.join(tmpdir, 'revlog.d')
                      shutil.copyfile(origindexpath, destindexpath)
                      shutil.copyfile(origdatapath, destdatapath)
                      # remove the data we want to add again
                      ui.debug('truncating data to be rewritten\n')
                      with open(destindexpath, 'ab') as index:
                          index.seek(0)
                          index.truncate(truncaterev * orig._io.size)
                      with open(destdatapath, 'ab') as data:
                          data.seek(0)
                          data.truncate(orig.start(truncaterev))
                      # instantiate a new revlog from the temporary copy
                      ui.debug('truncating adding to be rewritten\n')
                      vfs = vfsmod.vfs(tmpdir)
                      vfs.options = getattr(orig.opener, 'options', None)
                      try:
                          dest = revlog(vfs, radix=radix, **revlogkwargs)
                      except TypeError:
                          dest = revlog(
                              vfs, indexfile=indexname, datafile=dataname, **revlogkwargs
                          )
                      if dest._inline:
                          raise error.Abort('not supporting inline revlog (yet)')
                      # make sure internals are initialized
                      dest.revision(len(dest) - 1)
                      yield dest
                      del dest, vfs
                  finally:
                      shutil.rmtree(tmpdir, True)
              @command(
                  b'perf::revlogchunks|perfrevlogchunks',
                  revlogopts
                  + formatteropts
                  + [
                      (b'e', b'engines', b'', b'compression engines to use'),
                      (b's', b'startrev', 0, b'revision to start at'),
                  ],
                  b'-c|-m|FILE',
              )
              def perfrevlogchunks(ui, repo, file_=None, engines=None, startrev=0, **opts):
                  """Benchmark operations on revlog chunks.
                  Logically, each revlog is a collection of fulltext revisions. However,
                  stored within each revlog are "chunks" of possibly compressed data. This
                  data needs to be read and decompressed or compressed and written.
                  This command measures the time it takes to read+decompress and recompress
                  chunks in a revlog. It effectively isolates I/O and compression performance.
                  For measurements of higher-level operations like resolving revisions,
                  see ``perfrevlogrevisions`` and ``perfrevlogrevision``.
                  """
                  opts = _byteskwargs(opts)
                  rl = cmdutil.openrevlog(repo, b'perfrevlogchunks', file_, opts)
                  # _chunkraw was renamed to _getsegmentforrevs.
                  try:
                      segmentforrevs = rl._getsegmentforrevs
                  except AttributeError:
                      segmentforrevs = rl._chunkraw
                  # Verify engines argument.
                  if engines:
                      engines = {e.strip() for e in engines.split(b',')}
                      for engine in engines:
                          try:
                              util.compressionengines[engine]
                          except KeyError:
                              raise error.Abort(b'unknown compression engine: %s' % engine)
                  else:
                      engines = []
                      for e in util.compengines:
                          engine = util.compengines[e]
                          try:
                              if engine.available():
                                  engine.revlogcompressor().compress(b'dummy')
                                  engines.append(e)
                          except NotImplementedError:
                              pass
                  revs = list(rl.revs(startrev, len(rl) - 1))
                  def rlfh(rl):
                      if rl._inline:
                          indexfile = getattr(rl, '_indexfile', None)
                          if indexfile is None:
                              # compatibility with <= hg-5.8
                              indexfile = getattr(rl, 'indexfile')
                          return getsvfs(repo)(indexfile)
                      else:
                          datafile = getattr(rl, 'datafile', getattr(rl, 'datafile'))
                          return getsvfs(repo)(datafile)
                  def doread():
                      rl.clearcaches()
                      for rev in revs:
                          segmentforrevs(rev, rev)
                  def doreadcachedfh():
                      rl.clearcaches()
                      fh = rlfh(rl)
                      for rev in revs:
                          segmentforrevs(rev, rev, df=fh)
                  def doreadbatch():
                      rl.clearcaches()
                      segmentforrevs(revs[0], revs[-1])
                  def doreadbatchcachedfh():
                      rl.clearcaches()
                      fh = rlfh(rl)
                      segmentforrevs(revs[0], revs[-1], df=fh)
                  def dochunk():
                      rl.clearcaches()
                      fh = rlfh(rl)
                      for rev in revs:
                          rl._chunk(rev, df=fh)
                  chunks = [None]
                  def dochunkbatch():
                      rl.clearcaches()
                      fh = rlfh(rl)
                      # Save chunks as a side-effect.
                      chunks[0] = rl._chunks(revs, df=fh)
                  def docompress(compressor):
                      rl.clearcaches()
                      try:
                          # Swap in the requested compression engine.
                          oldcompressor = rl._compressor
                          rl._compressor = compressor
                          for chunk in chunks[0]:
                              rl.compress(chunk)
                      finally:
                          rl._compressor = oldcompressor
                  benches = [
                      (lambda: doread(), b'read'),
                      (lambda: doreadcachedfh(), b'read w/ reused fd'),
                      (lambda: doreadbatch(), b'read batch'),
                      (lambda: doreadbatchcachedfh(), b'read batch w/ reused fd'),
                      (lambda: dochunk(), b'chunk'),
                      (lambda: dochunkbatch(), b'chunk batch'),
                  ]
                  for engine in sorted(engines):
                      compressor = util.compengines[engine].revlogcompressor()
                      benches.append(
                          (
                              functools.partial(docompress, compressor),
                              b'compress w/ %s' % engine,
                          )
                      )
                  for fn, title in benches:
                      timer, fm = gettimer(ui, opts)
                      timer(fn, title=title)
                      fm.end()
              @command(
                  b'perf::revlogrevision|perfrevlogrevision',
                  revlogopts
                  + formatteropts
                  + [(b'', b'cache', False, b'use caches instead of clearing')],
                  b'-c|-m|FILE REV',
              )
              def perfrevlogrevision(ui, repo, file_, rev=None, cache=None, **opts):
                  """Benchmark obtaining a revlog revision.
                  Obtaining a revlog revision consists of roughly the following steps:
 . Compute the delta chain
 . Slice the delta chain if applicable
 . Obtain the raw chunks for that delta chain
 . Decompress each raw chunk
 . Apply binary patches to obtain fulltext
 . Verify hash of fulltext
                  This command measures the time spent in each of these phases.
                  """
                  opts = _byteskwargs(opts)
                  if opts.get(b'changelog') or opts.get(b'manifest'):
                      file_, rev = None, file_
                  elif rev is None:
                      raise error.CommandError(b'perfrevlogrevision', b'invalid arguments')
                  r = cmdutil.openrevlog(repo, b'perfrevlogrevision', file_, opts)
                  # _chunkraw was renamed to _getsegmentforrevs.
                  try:
                      segmentforrevs = r._getsegmentforrevs
                  except AttributeError:
                      segmentforrevs = r._chunkraw
                  node = r.lookup(rev)
                  rev = r.rev(node)
                  def getrawchunks(data, chain):
                      start = r.start
                      length = r.length
                      inline = r._inline
                      try:
                          iosize = r.index.entry_size
                      except AttributeError:
                          iosize = r._io.size
                      buffer = util.buffer
                      chunks = []
                      ladd = chunks.append
                      for idx, item in enumerate(chain):
                          offset = start(item[0])
                          bits = data[idx]
                          for rev in item:
                              chunkstart = start(rev)
                              if inline:
                                  chunkstart += (rev + 1) * iosize
                              chunklength = length(rev)
                              ladd(buffer(bits, chunkstart - offset, chunklength))
                      return chunks
                  def dodeltachain(rev):
                      if not cache:
                          r.clearcaches()
                      r._deltachain(rev)
                  def doread(chain):
                      if not cache:
                          r.clearcaches()
                      for item in slicedchain:
                          segmentforrevs(item[0], item[-1])
                  def doslice(r, chain, size):
                      for s in slicechunk(r, chain, targetsize=size):
                          pass
                  def dorawchunks(data, chain):
                      if not cache:
                          r.clearcaches()
                      getrawchunks(data, chain)
                  def dodecompress(chunks):
                      decomp = r.decompress
                      for chunk in chunks:
                          decomp(chunk)
                  def dopatch(text, bins):
                      if not cache:
                          r.clearcaches()
                      mdiff.patches(text, bins)
                  def dohash(text):
                      if not cache:
                          r.clearcaches()
                      r.checkhash(text, node, rev=rev)
                  def dorevision():
                      if not cache:
                          r.clearcaches()
                      r.revision(node)
                  try:
                      from mercurial.revlogutils.deltas import slicechunk
                  except ImportError:
                      slicechunk = getattr(revlog, '_slicechunk', None)
                  size = r.length(rev)
                  chain = r._deltachain(rev)[0]
                  if not getattr(r, '_withsparseread', False):
                      slicedchain = (chain,)
                  else:
                      slicedchain = tuple(slicechunk(r, chain, targetsize=size))
                  data = [segmentforrevs(seg[0], seg[-1])[1] for seg in slicedchain]
                  rawchunks = getrawchunks(data, slicedchain)
                  bins = r._chunks(chain)
                  text = bytes(bins[0])
                  bins = bins[1:]
                  text = mdiff.patches(text, bins)
                  benches = [
                      (lambda: dorevision(), b'full'),
                      (lambda: dodeltachain(rev), b'deltachain'),
                      (lambda: doread(chain), b'read'),
                  ]
                  if getattr(r, '_withsparseread', False):
                      slicing = (lambda: doslice(r, chain, size), b'slice-sparse-chain')
                      benches.append(slicing)
                  benches.extend(
                      [
                          (lambda: dorawchunks(data, slicedchain), b'rawchunks'),
                          (lambda: dodecompress(rawchunks), b'decompress'),
                          (lambda: dopatch(text, bins), b'patch'),
                          (lambda: dohash(text), b'hash'),
                      ]
                  )
                  timer, fm = gettimer(ui, opts)
                  for fn, title in benches:
                      timer(fn, title=title)
                  fm.end()
              @command(
                  b'perf::revset|perfrevset',
                  [
                      (b'C', b'clear', False, b'clear volatile cache between each call.'),
                      (b'', b'contexts', False, b'obtain changectx for each revision'),
                  ]
                  + formatteropts,
                  b"REVSET",
              )
              def perfrevset(ui, repo, expr, clear=False, contexts=False, **opts):
                  """benchmark the execution time of a revset
                  Use the --clean option if need to evaluate the impact of build volatile
                  revisions set cache on the revset execution. Volatile cache hold filtered
                  and obsolete related cache."""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  def d():
                      if clear:
                          repo.invalidatevolatilesets()
                      if contexts:
                          for ctx in repo.set(expr):
                              pass
                      else:
                          for r in repo.revs(expr):
                              pass
                  timer(d)
                  fm.end()
              @command(
                  b'perf::volatilesets|perfvolatilesets',
                  [
                      (b'', b'clear-obsstore', False, b'drop obsstore between each call.'),
                  ]
                  + formatteropts,
              )
              def perfvolatilesets(ui, repo, *names, **opts):
                  """benchmark the computation of various volatile set
                  Volatile set computes element related to filtering and obsolescence."""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  repo = repo.unfiltered()
                  def getobs(name):
                      def d():
                          repo.invalidatevolatilesets()
                          if opts[b'clear_obsstore']:
                              clearfilecache(repo, b'obsstore')
                          obsolete.getrevs(repo, name)
                      return d
                  allobs = sorted(obsolete.cachefuncs)
                  if names:
                      allobs = [n for n in allobs if n in names]
                  for name in allobs:
                      timer(getobs(name), title=name)
                  def getfiltered(name):
                      def d():
                          repo.invalidatevolatilesets()
                          if opts[b'clear_obsstore']:
                              clearfilecache(repo, b'obsstore')
                          repoview.filterrevs(repo, name)
                      return d
                  allfilter = sorted(repoview.filtertable)
                  if names:
                      allfilter = [n for n in allfilter if n in names]
                  for name in allfilter:
                      timer(getfiltered(name), title=name)
                  fm.end()
              @command(
                  b'perf::branchmap|perfbranchmap',
                  [
                      (b'f', b'full', False, b'Includes build time of subset'),
                      (
                          b'',
                          b'clear-revbranch',
                          False,
                          b'purge the revbranch cache between computation',
                      ),
                  ]
                  + formatteropts,
              )
              def perfbranchmap(ui, repo, *filternames, **opts):
                  """benchmark the update of a branchmap
                  This benchmarks the full repo.branchmap() call with read and write disabled
                  """
                  opts = _byteskwargs(opts)
                  full = opts.get(b"full", False)
                  clear_revbranch = opts.get(b"clear_revbranch", False)
                  timer, fm = gettimer(ui, opts)
                  def getbranchmap(filtername):
                      """generate a benchmark function for the filtername"""
                      if filtername is None:
                          view = repo
                      else:
                          view = repo.filtered(filtername)
                      if util.safehasattr(view._branchcaches, '_per_filter'):
                          filtered = view._branchcaches._per_filter
                      else:
                          # older versions
                          filtered = view._branchcaches
                      def d():
                          if clear_revbranch:
                              repo.revbranchcache()._clear()
                          if full:
                              view._branchcaches.clear()
                          else:
                              filtered.pop(filtername, None)
                          view.branchmap()
                      return d
                  # add filter in smaller subset to bigger subset
                  possiblefilters = set(repoview.filtertable)
                  if filternames:
                      possiblefilters &= set(filternames)
                  subsettable = getbranchmapsubsettable()
                  allfilters = []
                  while possiblefilters:
                      for name in possiblefilters:
                          subset = subsettable.get(name)
                          if subset not in possiblefilters:
                              break
                      else:
                          assert False, b'subset cycle %s!' % possiblefilters
                      allfilters.append(name)
                      possiblefilters.remove(name)
                  # warm the cache
                  if not full:
                      for name in allfilters:
                          repo.filtered(name).branchmap()
                  if not filternames or b'unfiltered' in filternames:
                      # add unfiltered
                      allfilters.append(None)
                  if util.safehasattr(branchmap.branchcache, 'fromfile'):
                      branchcacheread = safeattrsetter(branchmap.branchcache, b'fromfile')
                      branchcacheread.set(classmethod(lambda *args: None))
                  else:
                      # older versions
                      branchcacheread = safeattrsetter(branchmap, b'read')
                      branchcacheread.set(lambda *args: None)
                  branchcachewrite = safeattrsetter(branchmap.branchcache, b'write')
                  branchcachewrite.set(lambda *args: None)
                  try:
                      for name in allfilters:
                          printname = name
                          if name is None:
                              printname = b'unfiltered'
                          timer(getbranchmap(name), title=printname)
                  finally:
                      branchcacheread.restore()
                      branchcachewrite.restore()
                  fm.end()
              @command(
                  b'perf::branchmapupdate|perfbranchmapupdate',
                  [
                      (b'', b'base', [], b'subset of revision to start from'),
                      (b'', b'target', [], b'subset of revision to end with'),
                      (b'', b'clear-caches', False, b'clear cache between each runs'),
                  ]
                  + formatteropts,
              )
              def perfbranchmapupdate(ui, repo, base=(), target=(), **opts):
                  """benchmark branchmap update from for <base> revs to <target> revs
                  If `--clear-caches` is passed, the following items will be reset before
                  each update:
                      * the changelog instance and associated indexes
                      * the rev-branch-cache instance
                  Examples:
                     # update for the one last revision
                     $ hg perfbranchmapupdate --base 'not tip' --target 'tip'
                     $ update for change coming with a new branch
                     $ hg perfbranchmapupdate --base 'stable' --target 'default'
                  """
                  from mercurial import branchmap
                  from mercurial import repoview
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  clearcaches = opts[b'clear_caches']
                  unfi = repo.unfiltered()
                  x = [None]  # used to pass data between closure
                  # we use a `list` here to avoid possible side effect from smartset
                  baserevs = list(scmutil.revrange(repo, base))
                  targetrevs = list(scmutil.revrange(repo, target))
                  if not baserevs:
                      raise error.Abort(b'no revisions selected for --base')
                  if not targetrevs:
                      raise error.Abort(b'no revisions selected for --target')
                  # make sure the target branchmap also contains the one in the base
                  targetrevs = list(set(baserevs) | set(targetrevs))
                  targetrevs.sort()
                  cl = repo.changelog
                  allbaserevs = list(cl.ancestors(baserevs, inclusive=True))
                  allbaserevs.sort()
                  alltargetrevs = frozenset(cl.ancestors(targetrevs, inclusive=True))
                  newrevs = list(alltargetrevs.difference(allbaserevs))
                  newrevs.sort()
                  allrevs = frozenset(unfi.changelog.revs())
                  basefilterrevs = frozenset(allrevs.difference(allbaserevs))
                  targetfilterrevs = frozenset(allrevs.difference(alltargetrevs))
                  def basefilter(repo, visibilityexceptions=None):
                      return basefilterrevs
                  def targetfilter(repo, visibilityexceptions=None):
                      return targetfilterrevs
                  msg = b'benchmark of branchmap with %d revisions with %d new ones\n'
                  ui.status(msg % (len(allbaserevs), len(newrevs)))
                  if targetfilterrevs:
                      msg = b'(%d revisions still filtered)\n'
                      ui.status(msg % len(targetfilterrevs))
                  try:
                      repoview.filtertable[b'__perf_branchmap_update_base'] = basefilter
                      repoview.filtertable[b'__perf_branchmap_update_target'] = targetfilter
                      baserepo = repo.filtered(b'__perf_branchmap_update_base')
                      targetrepo = repo.filtered(b'__perf_branchmap_update_target')
                      # try to find an existing branchmap to reuse
                      subsettable = getbranchmapsubsettable()
                      candidatefilter = subsettable.get(None)
                      while candidatefilter is not None:
                          candidatebm = repo.filtered(candidatefilter).branchmap()
                          if candidatebm.validfor(baserepo):
                              filtered = repoview.filterrevs(repo, candidatefilter)
                              missing = [r for r in allbaserevs if r in filtered]
                              base = candidatebm.copy()
                              base.update(baserepo, missing)
                              break
                          candidatefilter = subsettable.get(candidatefilter)
                      else:
                          # no suitable subset where found
                          base = branchmap.branchcache()
                          base.update(baserepo, allbaserevs)
                      def setup():
                          x[0] = base.copy()
                          if clearcaches:
                              unfi._revbranchcache = None
                              clearchangelog(repo)
                      def bench():
                          x[0].update(targetrepo, newrevs)
                      timer(bench, setup=setup)
                      fm.end()
                  finally:
                      repoview.filtertable.pop(b'__perf_branchmap_update_base', None)
                      repoview.filtertable.pop(b'__perf_branchmap_update_target', None)
              @command(
                  b'perf::branchmapload|perfbranchmapload',
                  [
                      (b'f', b'filter', b'', b'Specify repoview filter'),
                      (b'', b'list', False, b'List brachmap filter caches'),
                      (b'', b'clear-revlogs', False, b'refresh changelog and manifest'),
                  ]
                  + formatteropts,
              )
              def perfbranchmapload(ui, repo, filter=b'', list=False, **opts):
                  """benchmark reading the branchmap"""
                  opts = _byteskwargs(opts)
                  clearrevlogs = opts[b'clear_revlogs']
                  if list:
                      for name, kind, st in repo.cachevfs.readdir(stat=True):
                          if name.startswith(b'branch2'):
                              filtername = name.partition(b'-')[2] or b'unfiltered'
                              ui.status(
                                  b'%s - %s\n' % (filtername, util.bytecount(st.st_size))
                              )
                      return
                  if not filter:
                      filter = None
                  subsettable = getbranchmapsubsettable()
                  if filter is None:
                      repo = repo.unfiltered()
                  else:
                      repo = repoview.repoview(repo, filter)
                  repo.branchmap()  # make sure we have a relevant, up to date branchmap
                  try:
                      fromfile = branchmap.branchcache.fromfile
                  except AttributeError:
                      # older versions
                      fromfile = branchmap.read
                  currentfilter = filter
                  # try once without timer, the filter may not be cached
                  while fromfile(repo) is None:
                      currentfilter = subsettable.get(currentfilter)
                      if currentfilter is None:
                          raise error.Abort(
                              b'No branchmap cached for %s repo' % (filter or b'unfiltered')
                          )
                      repo = repo.filtered(currentfilter)
                  timer, fm = gettimer(ui, opts)
                  def setup():
                      if clearrevlogs:
                          clearchangelog(repo)
                  def bench():
                      fromfile(repo)
                  timer(bench, setup=setup)
                  fm.end()
              @command(b'perf::loadmarkers|perfloadmarkers')
              def perfloadmarkers(ui, repo):
                  """benchmark the time to parse the on-disk markers for a repo
                  Result is the number of markers in the repo."""
                  timer, fm = gettimer(ui)
                  svfs = getsvfs(repo)
                  timer(lambda: len(obsolete.obsstore(repo, svfs)))
                  fm.end()
              @command(
                  b'perf::lrucachedict|perflrucachedict',
                  formatteropts
                  + [
                      (b'', b'costlimit', 0, b'maximum total cost of items in cache'),
                      (b'', b'mincost', 0, b'smallest cost of items in cache'),
                      (b'', b'maxcost', 100, b'maximum cost of items in cache'),
                      (b'', b'size', 4, b'size of cache'),
                      (b'', b'gets', 10000, b'number of key lookups'),
                      (b'', b'sets', 10000, b'number of key sets'),
                      (b'', b'mixed', 10000, b'number of mixed mode operations'),
                      (
                          b'',
                          b'mixedgetfreq',
 ,
                          b'frequency of get vs set ops in mixed mode',
                      ),
                  ],
                  norepo=True,
              )
              def perflrucache(
                  ui,
                  mincost=0,
                  maxcost=100,
                  costlimit=0,
                  size=4,
                  gets=10000,
                  sets=10000,
                  mixed=10000,
                  mixedgetfreq=50,
                  **opts
              ):
                  opts = _byteskwargs(opts)
                  def doinit():
                      for i in _xrange(10000):
                          util.lrucachedict(size)
                  costrange = list(range(mincost, maxcost + 1))
                  values = []
                  for i in _xrange(size):
                      values.append(random.randint(0, _maxint))
                  # Get mode fills the cache and tests raw lookup performance with no
                  # eviction.
                  getseq = []
                  for i in _xrange(gets):
                      getseq.append(random.choice(values))
                  def dogets():
                      d = util.lrucachedict(size)
                      for v in values:
                          d[v] = v
                      for key in getseq:
                          value = d[key]
                          value  # silence pyflakes warning
                  def dogetscost():
                      d = util.lrucachedict(size, maxcost=costlimit)
                      for i, v in enumerate(values):
                          d.insert(v, v, cost=costs[i])
                      for key in getseq:
                          try:
                              value = d[key]
                              value  # silence pyflakes warning
                          except KeyError:
                              pass
                  # Set mode tests insertion speed with cache eviction.
                  setseq = []
                  costs = []
                  for i in _xrange(sets):
                      setseq.append(random.randint(0, _maxint))
                      costs.append(random.choice(costrange))
                  def doinserts():
                      d = util.lrucachedict(size)
                      for v in setseq:
                          d.insert(v, v)
                  def doinsertscost():
                      d = util.lrucachedict(size, maxcost=costlimit)
                      for i, v in enumerate(setseq):
                          d.insert(v, v, cost=costs[i])
                  def dosets():
                      d = util.lrucachedict(size)
                      for v in setseq:
                          d[v] = v
                  # Mixed mode randomly performs gets and sets with eviction.
                  mixedops = []
                  for i in _xrange(mixed):
                      r = random.randint(0, 100)
                      if r < mixedgetfreq:
                          op = 0
                      else:
                          op = 1
                      mixedops.append(
                          (op, random.randint(0, size * 2), random.choice(costrange))
                      )
                  def domixed():
                      d = util.lrucachedict(size)
                      for op, v, cost in mixedops:
                          if op == 0:
                              try:
                                  d[v]
                              except KeyError:
                                  pass
                          else:
                              d[v] = v
                  def domixedcost():
                      d = util.lrucachedict(size, maxcost=costlimit)
                      for op, v, cost in mixedops:
                          if op == 0:
                              try:
                                  d[v]
                              except KeyError:
                                  pass
                          else:
                              d.insert(v, v, cost=cost)
                  benches = [
                      (doinit, b'init'),
                  ]
                  if costlimit:
                      benches.extend(
                          [
                              (dogetscost, b'gets w/ cost limit'),
                              (doinsertscost, b'inserts w/ cost limit'),
                              (domixedcost, b'mixed w/ cost limit'),
                          ]
                      )
                  else:
                      benches.extend(
                          [
                              (dogets, b'gets'),
                              (doinserts, b'inserts'),
                              (dosets, b'sets'),
                              (domixed, b'mixed'),
                          ]
                      )
                  for fn, title in benches:
                      timer, fm = gettimer(ui, opts)
                      timer(fn, title=title)
                      fm.end()
              @command(
                  b'perf::write|perfwrite',
                  formatteropts
                  + [
                      (b'', b'write-method', b'write', b'ui write method'),
                      (b'', b'nlines', 100, b'number of lines'),
                      (b'', b'nitems', 100, b'number of items (per line)'),
                      (b'', b'item', b'x', b'item that is written'),
                      (b'', b'batch-line', None, b'pass whole line to write method at once'),
                      (b'', b'flush-line', None, b'flush after each line'),
                  ],
              )
              def perfwrite(ui, repo, **opts):
                  """microbenchmark ui.write (and others)"""
                  opts = _byteskwargs(opts)
                  write = getattr(ui, _sysstr(opts[b'write_method']))
                  nlines = int(opts[b'nlines'])
                  nitems = int(opts[b'nitems'])
                  item = opts[b'item']
                  batch_line = opts.get(b'batch_line')
                  flush_line = opts.get(b'flush_line')
                  if batch_line:
                      line = item * nitems + b'\n'
                  def benchmark():
                      for i in pycompat.xrange(nlines):
                          if batch_line:
                              write(line)
                          else:
                              for i in pycompat.xrange(nitems):
                                  write(item)
                              write(b'\n')
                          if flush_line:
                              ui.flush()
                      ui.flush()
                  timer, fm = gettimer(ui, opts)
                  timer(benchmark)
                  fm.end()
              def uisetup(ui):
                  if util.safehasattr(cmdutil, b'openrevlog') and not util.safehasattr(
                      commands, b'debugrevlogopts'
                  ):
                      # for "historical portability":
                      # In this case, Mercurial should be 1.9 (or a79fea6b3e77) -
                      # 3.7 (or 5606f7d0d063). Therefore, '--dir' option for
                      # openrevlog() should cause failure, because it has been
                      # available since 3.5 (or 49c583ca48c4).
                      def openrevlog(orig, repo, cmd, file_, opts):
                          if opts.get(b'dir') and not util.safehasattr(repo, b'dirlog'):
                              raise error.Abort(
                                  b"This version doesn't support --dir option",
                                  hint=b"use 3.5 or later",
                              )
                          return orig(repo, cmd, file_, opts)
                      name = _sysstr(b'openrevlog')
                      extensions.wrapfunction(cmdutil, name, openrevlog)
              @command(
                  b'perf::progress|perfprogress',
                  formatteropts
                  + [
                      (b'', b'topic', b'topic', b'topic for progress messages'),
                      (b'c', b'total', 1000000, b'total value we are progressing to'),
                  ],
                  norepo=True,
              )
              def perfprogress(ui, topic=None, total=None, **opts):
                  """printing of progress bars"""
                  opts = _byteskwargs(opts)
                  timer, fm = gettimer(ui, opts)
                  def doprogress():
                      with ui.makeprogress(topic, total=total) as progress:
                          for i in _xrange(total):
                              progress.increment()
                  timer(doprogress)
                  fm.end()

hgext/convert/common.py

0 +5 -3

              # common.py - common code for the convert extension
              #
              #  Copyright 2005-2009 Olivia Mackall <olivia@selenic.com> and others
              #
              # This software may be used and distributed according to the terms of the
              # GNU General Public License version 2 or any later version.
              import base64
              import datetime
              import os
              import pickle
              import re
              import shlex
              import subprocess
              from mercurial.i18n import _
              from mercurial.pycompat import open
              from mercurial import (
                  encoding,
                  error,
                  phases,
                  pycompat,
                  util,
              )
              from mercurial.utils import procutil
              propertycache = util.propertycache
              def _encodeornone(d):
                  if d is None:
                      return
                  return d.encode('latin1')
              class _shlexpy3proxy:
                  def __init__(self, l):
                      self._l = l
                  def __iter__(self):
                      return (_encodeornone(v) for v in self._l)
                  def get_token(self):
                      return _encodeornone(self._l.get_token())
                  @property
                  def infile(self):
                      return self._l.infile or b'<unknown>'
                  @property
                  def lineno(self):
                      return self._l.lineno
              def shlexer(data=None, filepath=None, wordchars=None, whitespace=None):
                  if data is None:
                      data = open(filepath, b'r', encoding='latin1')
                  else:
                      if filepath is not None:
                          raise error.ProgrammingError(
                              b'shlexer only accepts data or filepath, not both'
                          )
                      data = data.decode('latin1')
                  l = shlex.shlex(data, infile=filepath, posix=True)
                  if whitespace is not None:
                      l.whitespace_split = True
                      l.whitespace += whitespace.decode('latin1')
                  if wordchars is not None:
                      l.wordchars += wordchars.decode('latin1')
                  return _shlexpy3proxy(l)
              def encodeargs(args):
                  def encodearg(s):
                      lines = base64.encodebytes(s)
                      lines = [l.splitlines()[0] for l in pycompat.iterbytestr(lines)]
                      return b''.join(lines)
                  s = pickle.dumps(args)
                  return encodearg(s)
              def decodeargs(s):
                  s = base64.decodebytes(s)
                  return pickle.loads(s)
              class MissingTool(Exception):
                  pass
              def checktool(exe, name=None, abort=True):
                  name = name or exe
                  if not procutil.findexe(exe):
                      if abort:
                          exc = error.Abort
                      else:
                          exc = MissingTool
                      raise exc(_(b'cannot find required "%s" tool') % name)
              class NoRepo(Exception):
                  pass
              SKIPREV = b'SKIP'
              class commit:
                  def __init__(
                      self,
                      author,
                      date,
                      desc,
                      parents,
                      branch=None,
                      rev=None,
                      extra=None,
                      sortkey=None,
                      saverev=True,
                      phase=phases.draft,
                      optparents=None,
                      ctx=None,
                  ):
                      self.author = author or b'unknown'
                      self.date = date or b'0 0'
                      self.desc = desc
                      self.parents = parents  # will be converted and used as parents
                      self.optparents = optparents or []  # will be used if already converted
                      self.branch = branch
                      self.rev = rev
                      self.extra = extra or {}
                      self.sortkey = sortkey
                      self.saverev = saverev
                      self.phase = phase
                      self.ctx = ctx  # for hg to hg conversions
              class converter_source:
                  """Conversion source interface"""
                  def __init__(self, ui, repotype, path=None, revs=None):
                      """Initialize conversion source (or raise NoRepo("message")
                      exception if path is not a valid repository)"""
                      self.ui = ui
                      self.path = path
                      self.revs = revs
                      self.repotype = repotype
                      self.encoding = b'utf-8'
                  def checkhexformat(self, revstr, mapname=b'splicemap'):
                      """fails if revstr is not a 40 byte hex. mercurial and git both uses
                      such format for their revision numbering
                      """
                      if not re.match(br'[0-9a-fA-F]{40,40}$', revstr):
                          raise error.Abort(
                              _(b'%s entry %s is not a valid revision identifier')
                              % (mapname, revstr)
                          )
                  def before(self):
                      pass
                  def after(self):
                      pass
                  def targetfilebelongstosource(self, targetfilename):
                      """Returns true if the given targetfile belongs to the source repo. This
                      is useful when only a subdirectory of the target belongs to the source
                      repo."""
                      # For normal full repo converts, this is always True.
                      return True
                  def setrevmap(self, revmap):
                      """set the map of already-converted revisions"""
                  def getheads(self):
                      """Return a list of this repository's heads"""
                      raise NotImplementedError
                  def getfile(self, name, rev):
                      """Return a pair (data, mode) where data is the file content
                      as a string and mode one of '', 'x' or 'l'. rev is the
                      identifier returned by a previous call to getchanges().
                      Data is None if file is missing/deleted in rev.
                      """
                      raise NotImplementedError
                  def getchanges(self, version, full):
                      """Returns a tuple of (files, copies, cleanp2).
                      files is a sorted list of (filename, id) tuples for all files
                      changed between version and its first parent returned by
                      getcommit(). If full, all files in that revision is returned.
                      id is the source revision id of the file.
                      copies is a dictionary of dest: source
                      cleanp2 is the set of files filenames that are clean against p2.
                      (Files that are clean against p1 are already not in files (unless
                      full). This makes it possible to handle p2 clean files similarly.)
                      """
                      raise NotImplementedError
                  def getcommit(self, version):
                      """Return the commit object for version"""
                      raise NotImplementedError
                  def numcommits(self):
                      """Return the number of commits in this source.
                      If unknown, return None.
                      """
                      return None
                  def gettags(self):
                      """Return the tags as a dictionary of name: revision
                      Tag names must be UTF-8 strings.
                      """
                      raise NotImplementedError
                  def recode(self, s, encoding=None):
                      if not encoding:
                          encoding = self.encoding or b'utf-8'
                      if isinstance(s, str):
                          return s.encode("utf-8")
                      try:
                          return s.decode(pycompat.sysstr(encoding)).encode("utf-8")
                      except UnicodeError:
                          try:
                              return s.decode("latin-1").encode("utf-8")
                          except UnicodeError:
                              return s.decode(pycompat.sysstr(encoding), "replace").encode(
                                  "utf-8"
                              )
                  def getchangedfiles(self, rev, i):
                      """Return the files changed by rev compared to parent[i].
                      i is an index selecting one of the parents of rev.  The return
                      value should be the list of files that are different in rev and
                      this parent.
                      If rev has no parents, i is None.
                      This function is only needed to support --filemap
                      """
                      raise NotImplementedError
                  def converted(self, rev, sinkrev):
                      '''Notify the source that a revision has been converted.'''
                  def hasnativeorder(self):
                      """Return true if this source has a meaningful, native revision
                      order. For instance, Mercurial revisions are store sequentially
                      while there is no such global ordering with Darcs.
                      """
                      return False
                  def hasnativeclose(self):
                      """Return true if this source has ability to close branch."""
                      return False
                  def lookuprev(self, rev):
                      """If rev is a meaningful revision reference in source, return
                      the referenced identifier in the same format used by getcommit().
                      return None otherwise.
                      """
                      return None
                  def getbookmarks(self):
                      """Return the bookmarks as a dictionary of name: revision
                      Bookmark names are to be UTF-8 strings.
                      """
                      return {}
                  def checkrevformat(self, revstr, mapname=b'splicemap'):
                      """revstr is a string that describes a revision in the given
                      source control system.  Return true if revstr has correct
                      format.
                      """
                      return True
              class converter_sink:
                  """Conversion sink (target) interface"""
                  def __init__(self, ui, repotype, path):
                      """Initialize conversion sink (or raise NoRepo("message")
                      exception if path is not a valid repository)
                      created is a list of paths to remove if a fatal error occurs
                      later"""
                      self.ui = ui
                      self.path = path
                      self.created = []
                      self.repotype = repotype
                  def revmapfile(self):
                      """Path to a file that will contain lines
                      source_rev_id sink_rev_id
                      mapping equivalent revision identifiers for each system."""
                      raise NotImplementedError
                  def authorfile(self):
                      """Path to a file that will contain lines
                      srcauthor=dstauthor
                      mapping equivalent authors identifiers for each system."""
                      return None
                  def putcommit(
                      self, files, copies, parents, commit, source, revmap, full, cleanp2
                  ):
                      """Create a revision with all changed files listed in 'files'
                      and having listed parents. 'commit' is a commit object
                      containing at a minimum the author, date, and message for this
                      changeset.  'files' is a list of (path, version) tuples,
                      'copies' is a dictionary mapping destinations to sources,
                      'source' is the source repository, and 'revmap' is a mapfile
                      of source revisions to converted revisions. Only getfile() and
                      lookuprev() should be called on 'source'. 'full' means that 'files'
                      is complete and all other files should be removed.
                      'cleanp2' is a set of the filenames that are unchanged from p2
                      (only in the common merge case where there two parents).
                      Note that the sink repository is not told to update itself to
                      a particular revision (or even what that revision would be)
                      before it receives the file data.
                      """
                      raise NotImplementedError
                  def puttags(self, tags):
                      """Put tags into sink.
                      tags: {tagname: sink_rev_id, ...} where tagname is an UTF-8 string.
                      Return a pair (tag_revision, tag_parent_revision), or (None, None)
                      if nothing was changed.
                      """
                      raise NotImplementedError
                  def setbranch(self, branch, pbranches):
                      """Set the current branch name. Called before the first putcommit
                      on the branch.
                      branch: branch name for subsequent commits
                      pbranches: (converted parent revision, parent branch) tuples"""
                  def setfilemapmode(self, active):
                      """Tell the destination that we're using a filemap
                      Some converter_sources (svn in particular) can claim that a file
                      was changed in a revision, even if there was no change.  This method
                      tells the destination that we're using a filemap and that it should
                      filter empty revisions.
                      """
                  def before(self):
                      pass
                  def after(self):
                      pass
                  def putbookmarks(self, bookmarks):
                      """Put bookmarks into sink.
                      bookmarks: {bookmarkname: sink_rev_id, ...}
                      where bookmarkname is an UTF-8 string.
                      """
                  def hascommitfrommap(self, rev):
                      """Return False if a rev mentioned in a filemap is known to not be
                      present."""
                      raise NotImplementedError
                  def hascommitforsplicemap(self, rev):
                      """This method is for the special needs for splicemap handling and not
                      for general use. Returns True if the sink contains rev, aborts on some
                      special cases."""
                      raise NotImplementedError
              class commandline:
                  def __init__(self, ui, command):
                      self.ui = ui
                      self.command = command
                  def prerun(self):
                      pass
                  def postrun(self):
                      pass
                  def _cmdline(self, cmd, *args, **kwargs):
                      kwargs = pycompat.byteskwargs(kwargs)
                      cmdline = [self.command, cmd] + list(args)
                      for k, v in kwargs.items():
                          if len(k) == 1:
                              cmdline.append(b'-' + k)
                          else:
                              cmdline.append(b'--' + k.replace(b'_', b'-'))
                          try:
                              if len(k) == 1:
                                  cmdline.append(b'' + v)
                              else:
                                  cmdline[-1] += b'=' + v
                          except TypeError:
                              pass
                      cmdline = [procutil.shellquote(arg) for arg in cmdline]
                      if not self.ui.debugflag:
                          cmdline += [b'2>', pycompat.bytestr(os.devnull)]
                      cmdline = b' '.join(cmdline)
                      return cmdline
                  def _run(self, cmd, *args, **kwargs):
                      def popen(cmdline):
                          p = subprocess.Popen(
                              procutil.tonativestr(cmdline),
                              shell=True,
                              bufsize=-1,
                              close_fds=procutil.closefds,
                              stdout=subprocess.PIPE,
                          )
                          return p
                      return self._dorun(popen, cmd, *args, **kwargs)
                  def _run2(self, cmd, *args, **kwargs):
                      return self._dorun(procutil.popen2, cmd, *args, **kwargs)
                  def _run3(self, cmd, *args, **kwargs):
                      return self._dorun(procutil.popen3, cmd, *args, **kwargs)
                  def _dorun(self, openfunc, cmd, *args, **kwargs):
                      cmdline = self._cmdline(cmd, *args, **kwargs)
                      self.ui.debug(b'running: %s\n' % (cmdline,))
                      self.prerun()
                      try:
                          return openfunc(cmdline)
                      finally:
                          self.postrun()
                  def run(self, cmd, *args, **kwargs):
                      p = self._run(cmd, *args, **kwargs)
                      output = p.communicate()[0]
                      self.ui.debug(output)
                      return output, p.returncode
                  def runlines(self, cmd, *args, **kwargs):
                      p = self._run(cmd, *args, **kwargs)
                      output = p.stdout.readlines()
                      p.wait()
                      self.ui.debug(b''.join(output))
                      return output, p.returncode
                  def checkexit(self, status, output=b''):
                      if status:
                          if output:
                              self.ui.warn(_(b'%s error:\n') % self.command)
                              self.ui.warn(output)
                          msg = procutil.explainexit(status)
                          raise error.Abort(b'%s %s' % (self.command, msg))
                  def run0(self, cmd, *args, **kwargs):
                      output, status = self.run(cmd, *args, **kwargs)
                      self.checkexit(status, output)
                      return output
                  def runlines0(self, cmd, *args, **kwargs):
                      output, status = self.runlines(cmd, *args, **kwargs)
                      self.checkexit(status, b''.join(output))
                      return output
                  @propertycache
                  def argmax(self):
                      # POSIX requires at least 4096 bytes for ARG_MAX
                      argmax = 4096
                      try:
                          argmax = os.sysconf("SC_ARG_MAX")
                      except (AttributeError, ValueError):
                          pass
                      # Windows shells impose their own limits on command line length,
                      # down to 2047 bytes for cmd.exe under Windows NT/2k and 2500 bytes
                      # for older 4nt.exe. See http://support.microsoft.com/kb/830473 for
                      # details about cmd.exe limitations.
                      # Since ARG_MAX is for command line _and_ environment, lower our limit
                      # (and make happy Windows shells while doing this).
                      return argmax // 2 - 1
                  def _limit_arglist(self, arglist, cmd, *args, **kwargs):
                      cmdlen = len(self._cmdline(cmd, *args, **kwargs))
                      limit = self.argmax - cmdlen
                      numbytes = 0
                      fl = []
                      for fn in arglist:
                          b = len(fn) + 3
                          if numbytes + b < limit or len(fl) == 0:
                              fl.append(fn)
                              numbytes += b
                          else:
                              yield fl
                              fl = [fn]
                              numbytes = b
                      if fl:
                          yield fl
                  def xargs(self, arglist, cmd, *args, **kwargs):
                      for l in self._limit_arglist(arglist, cmd, *args, **kwargs):
                          self.run0(cmd, *(list(args) + l), **kwargs)
              class mapfile(dict):
                  def __init__(self, ui, path):
                      super(mapfile, self).__init__()
                      self.ui = ui
                      self.path = path
                      self.fp = None
                      self.order = []
                      self._read()
                  def _read(self):
                      if not self.path:
                          return
                      try:
                          fp = open(self.path, b'rb')
                      except FileNotFoundError:
                          return
                      for i, line in enumerate(fp):
                          line = line.splitlines()[0].rstrip()
                          if not line:
                              # Ignore blank lines
                              continue
                          try:
                              key, value = line.rsplit(b' ', 1)
                          except ValueError:
                              raise error.Abort(
                                  _(b'syntax error in %s(%d): key/value pair expected')
                                  % (self.path, i + 1)
                              )
                          if key not in self:
                              self.order.append(key)
                          super(mapfile, self).__setitem__(key, value)
                      fp.close()
                  def __setitem__(self, key, value):
                      if self.fp is None:
                          try:
                              self.fp = open(self.path, b'ab')
                          except IOError as err:
                              raise error.Abort(
                                  _(b'could not open map file %r: %s')
                                  % (self.path, encoding.strtolocal(err.strerror))
                              )
                      self.fp.write(util.tonativeeol(b'%s %s\n' % (key, value)))
                      self.fp.flush()
                      super(mapfile, self).__setitem__(key, value)
                  def close(self):
                      if self.fp:
                          self.fp.close()
                          self.fp = None
              def makedatetimestamp(t):
                  """Like dateutil.makedate() but for time t instead of current time"""
-                 delta = datetime.datetime.utcfromtimestamp(
+                 tz = round(
                      t
-                 ) - datetime.datetime.fromtimestamp(t)
-                 tz = delta.days * 86400 + delta.seconds
+                     - datetime.datetime.fromtimestamp(t)
+                     .replace(tzinfo=datetime.timezone.utc)
+                     .timestamp()
+                 )
                  return t, tz

mercurial/extensions.py

0 +35 -21

              # extensions.py - extension handling for mercurial
              #
              # Copyright 2005-2007 Olivia Mackall <olivia@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.
              import ast
              import collections
              import functools
-             import imp
+             import importlib
              import inspect
              import os
+             import sys
              from .i18n import (
                  _,
                  gettext,
              )
              from .pycompat import (
                  getattr,
                  open,
                  setattr,
              )
              from . import (
                  cmdutil,
                  configitems,
                  error,
                  pycompat,
                  util,
              )
              from .utils import stringutil
              _extensions = {}
              _disabledextensions = {}
              _aftercallbacks = {}
              _order = []
              _builtin = {
                  b'hbisect',
                  b'bookmarks',
                  b'color',
                  b'parentrevspec',
                  b'progress',
                  b'interhg',
                  b'inotify',
                  b'hgcia',
                  b'shelve',
              }
              def extensions(ui=None):
                  if ui:
                      def enabled(name):
                          for format in [b'%s', b'hgext.%s']:
                              conf = ui.config(b'extensions', format % name)
                              if conf is not None and not conf.startswith(b'!'):
                                  return True
                  else:
                      enabled = lambda name: True
                  for name in _order:
                      module = _extensions[name]
                      if module and enabled(name):
                          yield name, module
              def find(name):
                  '''return module with given extension name'''
                  mod = None
                  try:
                      mod = _extensions[name]
                  except KeyError:
                      for k, v in _extensions.items():
                          if k.endswith(b'.' + name) or k.endswith(b'/' + name):
                              mod = v
                              break
                  if not mod:
                      raise KeyError(name)
                  return mod
              def loadpath(path, module_name):
                  module_name = module_name.replace(b'.', b'_')
                  path = util.normpath(util.expandpath(path))
                  module_name = pycompat.fsdecode(module_name)
                  path = pycompat.fsdecode(path)
                  if os.path.isdir(path):
                      # module/__init__.py style
-                     d, f = os.path.split(path)
-                     fd, fpath, desc = imp.find_module(f, [d])
-                     # When https://github.com/python/typeshed/issues/3466 is fixed
-                     # and in a pytype release we can drop this disable.
-                     return imp.load_module(
-                         module_name, fd, fpath, desc  # pytype: disable=wrong-arg-types
+                     )
-                 else:
-                     try:
-                         return imp.load_source(module_name, path)
-                     except IOError as exc:
-                         if not exc.filename:
-                             exc.filename = path  # python does not fill this
-                         raise
+                     init_py_path = os.path.join(path, '__init__.py')
+                     if not os.path.exists(init_py_path):
+                         raise ImportError("No module named '%s'" % os.path.basename(path))
+                     path = init_py_path
+                 loader = importlib.machinery.SourceFileLoader(module_name, path)
+                 spec = importlib.util.spec_from_file_location(module_name, loader=loader)
+                 assert spec is not None  # help Pytype
+                 module = importlib.util.module_from_spec(spec)
+                 sys.modules[module_name] = module
+                 spec.loader.exec_module(module)
+                 return module
              def _importh(name):
                  """import and return the <name> module"""
                  mod = __import__(pycompat.sysstr(name))
                  components = name.split(b'.')
                  for comp in components[1:]:
                      mod = getattr(mod, comp)
                  return mod
              def _importext(name, path=None, reportfunc=None):
                  if path:
                      # the module will be loaded in sys.modules
                      # choose an unique name so that it doesn't
                      # conflicts with other modules
                      mod = loadpath(path, b'hgext.%s' % name)
                  else:
                      try:
                          mod = _importh(b"hgext.%s" % name)
                      except ImportError as err:
                          if reportfunc:
                              reportfunc(err, b"hgext.%s" % name, b"hgext3rd.%s" % name)
                          try:
                              mod = _importh(b"hgext3rd.%s" % name)
                          except ImportError as err:
                              if reportfunc:
                                  reportfunc(err, b"hgext3rd.%s" % name, name)
                              mod = _importh(name)
                  return mod
              def _reportimporterror(ui, err, failed, next):
                  # note: this ui.log happens before --debug is processed,
                  #       Use --config ui.debug=1 to see them.
                  ui.log(
                      b'extension',
                      b'    - could not import %s (%s): trying %s\n',
                      failed,
                      stringutil.forcebytestr(err),
                      next,
                  )
                  if ui.debugflag and ui.configbool(b'devel', b'debug.extensions'):
                      ui.traceback()
              def _rejectunicode(name, xs):
                  if isinstance(xs, (list, set, tuple)):
                      for x in xs:
                          _rejectunicode(name, x)
                  elif isinstance(xs, dict):
                      for k, v in xs.items():
                          _rejectunicode(name, k)
                          _rejectunicode(b'%s.%s' % (name, stringutil.forcebytestr(k)), v)
                  elif isinstance(xs, type(u'')):
                      raise error.ProgrammingError(
                          b"unicode %r found in %s" % (xs, name),
                          hint=b"use b'' to make it byte string",
                      )
              # attributes set by registrar.command
              _cmdfuncattrs = (b'norepo', b'optionalrepo', b'inferrepo')
              def _validatecmdtable(ui, cmdtable):
                  """Check if extension commands have required attributes"""
                  for c, e in cmdtable.items():
                      f = e[0]
                      missing = [a for a in _cmdfuncattrs if not util.safehasattr(f, a)]
                      if not missing:
                          continue
                      raise error.ProgrammingError(
                          b'missing attributes: %s' % b', '.join(missing),
                          hint=b"use @command decorator to register '%s'" % c,
                      )
              def _validatetables(ui, mod):
                  """Sanity check for loadable tables provided by extension module"""
                  for t in [b'cmdtable', b'colortable', b'configtable']:
                      _rejectunicode(t, getattr(mod, t, {}))
                  for t in [
                      b'filesetpredicate',
                      b'internalmerge',
                      b'revsetpredicate',
                      b'templatefilter',
                      b'templatefunc',
                      b'templatekeyword',
                  ]:
                      o = getattr(mod, t, None)
                      if o:
                          _rejectunicode(t, o._table)
                  _validatecmdtable(ui, getattr(mod, 'cmdtable', {}))
              def load(ui, name, path, loadingtime=None):
                  if name.startswith(b'hgext.') or name.startswith(b'hgext/'):
                      shortname = name[6:]
                  else:
                      shortname = name
                  if shortname in _builtin:
                      return None
                  if shortname in _extensions:
                      return _extensions[shortname]
                  ui.log(b'extension', b'  - loading extension: %s\n', shortname)
                  _extensions[shortname] = None
                  with util.timedcm('load extension %s', shortname) as stats:
                      mod = _importext(name, path, bind(_reportimporterror, ui))
                  ui.log(b'extension', b'  > %s extension loaded in %s\n', shortname, stats)
                  if loadingtime is not None:
                      loadingtime[shortname] += stats.elapsed
                  # Before we do anything with the extension, check against minimum stated
                  # compatibility. This gives extension authors a mechanism to have their
                  # extensions short circuit when loaded with a known incompatible version
                  # of Mercurial.
                  minver = getattr(mod, 'minimumhgversion', None)
                  if minver:
                      curver = util.versiontuple(n=2)
                      extmin = util.versiontuple(stringutil.forcebytestr(minver), 2)
                      if None in extmin:
                          extmin = (extmin[0] or 0, extmin[1] or 0)
                      if None in curver or extmin > curver:
                          msg = _(
                              b'(third party extension %s requires version %s or newer '
                              b'of Mercurial (current: %s); disabling)\n'
                          )
                          ui.warn(msg % (shortname, minver, util.version()))
                          return
                  ui.log(b'extension', b'    - validating extension tables: %s\n', shortname)
                  _validatetables(ui, mod)
                  _extensions[shortname] = mod
                  _order.append(shortname)
                  ui.log(
                      b'extension', b'    - invoking registered callbacks: %s\n', shortname
                  )
                  with util.timedcm('callbacks extension %s', shortname) as stats:
                      for fn in _aftercallbacks.get(shortname, []):
                          fn(loaded=True)
                  ui.log(b'extension', b'    > callbacks completed in %s\n', stats)
                  return mod
              def _runuisetup(name, ui):
                  uisetup = getattr(_extensions[name], 'uisetup', None)
                  if uisetup:
                      try:
                          uisetup(ui)
                      except Exception as inst:
                          ui.traceback(force=True)
                          msg = stringutil.forcebytestr(inst)
                          ui.warn(_(b"*** failed to set up extension %s: %s\n") % (name, msg))
                          return False
                  return True
              def _runextsetup(name, ui):
                  extsetup = getattr(_extensions[name], 'extsetup', None)
                  if extsetup:
                      try:
                          extsetup(ui)
                      except Exception as inst:
                          ui.traceback(force=True)
                          msg = stringutil.forcebytestr(inst)
                          ui.warn(_(b"*** failed to set up extension %s: %s\n") % (name, msg))
                          return False
                  return True
              def loadall(ui, whitelist=None):
                  loadingtime = collections.defaultdict(int)
                  result = ui.configitems(b"extensions")
                  if whitelist is not None:
                      result = [(k, v) for (k, v) in result if k in whitelist]
                  result = [(k, v) for (k, v) in result if b':' not in k]
                  newindex = len(_order)
                  ui.log(
                      b'extension',
                      b'loading %sextensions\n',
                      b'additional ' if newindex else b'',
                  )
                  ui.log(b'extension', b'- processing %d entries\n', len(result))
                  with util.timedcm('load all extensions') as stats:
                      default_sub_options = ui.configsuboptions(b"extensions", b"*")[1]
                      for (name, path) in result:
                          if path:
                              if path[0:1] == b'!':
                                  if name not in _disabledextensions:
                                      ui.log(
                                          b'extension',
                                          b'  - skipping disabled extension: %s\n',
                                          name,
                                      )
                                  _disabledextensions[name] = path[1:]
                                  continue
                          try:
                              load(ui, name, path, loadingtime)
                          except Exception as inst:
                              msg = stringutil.forcebytestr(inst)
                              if path:
                                  error_msg = _(
                                      b'failed to import extension "%s" from %s: %s'
                                  )
                                  error_msg %= (name, path, msg)
                              else:
                                  error_msg = _(b'failed to import extension "%s": %s')
                                  error_msg %= (name, msg)
                              options = default_sub_options.copy()
                              ext_options = ui.configsuboptions(b"extensions", name)[1]
                              options.update(ext_options)
                              if stringutil.parsebool(options.get(b"required", b'no')):
                                  hint = None
                                  if isinstance(inst, error.Hint) and inst.hint:
                                      hint = inst.hint
                                  if hint is None:
                                      hint = _(
                                          b"loading of this extension was required, "
                                          b"see `hg help config.extensions` for details"
                                      )
                                  raise error.Abort(error_msg, hint=hint)
                              else:
                                  ui.warn((b"*** %s\n") % error_msg)
                                  if isinstance(inst, error.Hint) and inst.hint:
                                      ui.warn(_(b"*** (%s)\n") % inst.hint)
                                  ui.traceback()
                  ui.log(
                      b'extension',
                      b'> loaded %d extensions, total time %s\n',
                      len(_order) - newindex,
                      stats,
                  )
                  # list of (objname, loadermod, loadername) tuple:
                  # - objname is the name of an object in extension module,
                  #   from which extra information is loaded
                  # - loadermod is the module where loader is placed
                  # - loadername is the name of the function,
                  #   which takes (ui, extensionname, extraobj) arguments
                  #
                  # This one is for the list of item that must be run before running any setup
                  earlyextraloaders = [
                      (b'configtable', configitems, b'loadconfigtable'),
                  ]
                  ui.log(b'extension', b'- loading configtable attributes\n')
                  _loadextra(ui, newindex, earlyextraloaders)
                  broken = set()
                  ui.log(b'extension', b'- executing uisetup hooks\n')
                  with util.timedcm('all uisetup') as alluisetupstats:
                      for name in _order[newindex:]:
                          ui.log(b'extension', b'  - running uisetup for %s\n', name)
                          with util.timedcm('uisetup %s', name) as stats:
                              if not _runuisetup(name, ui):
                                  ui.log(
                                      b'extension',
                                      b'    - the %s extension uisetup failed\n',
                                      name,
                                  )
                                  broken.add(name)
                          ui.log(b'extension', b'  > uisetup for %s took %s\n', name, stats)
                          loadingtime[name] += stats.elapsed
                  ui.log(b'extension', b'> all uisetup took %s\n', alluisetupstats)
                  ui.log(b'extension', b'- executing extsetup hooks\n')
                  with util.timedcm('all extsetup') as allextetupstats:
                      for name in _order[newindex:]:
                          if name in broken:
                              continue
                          ui.log(b'extension', b'  - running extsetup for %s\n', name)
                          with util.timedcm('extsetup %s', name) as stats:
                              if not _runextsetup(name, ui):
                                  ui.log(
                                      b'extension',
                                      b'    - the %s extension extsetup failed\n',
                                      name,
                                  )
                                  broken.add(name)
                          ui.log(b'extension', b'  > extsetup for %s took %s\n', name, stats)
                          loadingtime[name] += stats.elapsed
                  ui.log(b'extension', b'> all extsetup took %s\n', allextetupstats)
                  for name in broken:
                      ui.log(b'extension', b'    - disabling broken %s extension\n', name)
                      _extensions[name] = None
                  # Call aftercallbacks that were never met.
                  ui.log(b'extension', b'- executing remaining aftercallbacks\n')
                  with util.timedcm('aftercallbacks') as stats:
                      for shortname in _aftercallbacks:
                          if shortname in _extensions:
                              continue
                          for fn in _aftercallbacks[shortname]:
                              ui.log(
                                  b'extension',
                                  b'  - extension %s not loaded, notify callbacks\n',
                                  shortname,
                              )
                              fn(loaded=False)
                  ui.log(b'extension', b'> remaining aftercallbacks completed in %s\n', stats)
                  # loadall() is called multiple times and lingering _aftercallbacks
                  # entries could result in double execution. See issue4646.
                  _aftercallbacks.clear()
                  # delay importing avoids cyclic dependency (especially commands)
                  from . import (
                      color,
                      commands,
                      filemerge,
                      fileset,
                      revset,
                      templatefilters,
                      templatefuncs,
                      templatekw,
                  )
                  # list of (objname, loadermod, loadername) tuple:
                  # - objname is the name of an object in extension module,
                  #   from which extra information is loaded
                  # - loadermod is the module where loader is placed
                  # - loadername is the name of the function,
                  #   which takes (ui, extensionname, extraobj) arguments
                  ui.log(b'extension', b'- loading extension registration objects\n')
                  extraloaders = [
                      (b'cmdtable', commands, b'loadcmdtable'),
                      (b'colortable', color, b'loadcolortable'),
                      (b'filesetpredicate', fileset, b'loadpredicate'),
                      (b'internalmerge', filemerge, b'loadinternalmerge'),
                      (b'revsetpredicate', revset, b'loadpredicate'),
                      (b'templatefilter', templatefilters, b'loadfilter'),
                      (b'templatefunc', templatefuncs, b'loadfunction'),
                      (b'templatekeyword', templatekw, b'loadkeyword'),
                  ]
                  with util.timedcm('load registration objects') as stats:
                      _loadextra(ui, newindex, extraloaders)
                  ui.log(
                      b'extension',
                      b'> extension registration object loading took %s\n',
                      stats,
                  )
                  # Report per extension loading time (except reposetup)
                  for name in sorted(loadingtime):
                      ui.log(
                          b'extension',
                          b'> extension %s take a total of %s to load\n',
                          name,
                          util.timecount(loadingtime[name]),
                      )
                  ui.log(b'extension', b'extension loading complete\n')
              def _loadextra(ui, newindex, extraloaders):
                  for name in _order[newindex:]:
                      module = _extensions[name]
                      if not module:
                          continue  # loading this module failed
                      for objname, loadermod, loadername in extraloaders:
                          extraobj = getattr(module, objname, None)
                          if extraobj is not None:
                              getattr(loadermod, loadername)(ui, name, extraobj)
              def afterloaded(extension, callback):
                  """Run the specified function after a named extension is loaded.
                  If the named extension is already loaded, the callback will be called
                  immediately.
                  If the named extension never loads, the callback will be called after
                  all extensions have been loaded.
                  The callback receives the named argument ``loaded``, which is a boolean
                  indicating whether the dependent extension actually loaded.
                  """
                  if extension in _extensions:
                      # Report loaded as False if the extension is disabled
                      loaded = _extensions[extension] is not None
                      callback(loaded=loaded)
                  else:
                      _aftercallbacks.setdefault(extension, []).append(callback)
              def populateui(ui):
                  """Run extension hooks on the given ui to populate additional members,
                  extend the class dynamically, etc.
                  This will be called after the configuration is loaded, and/or extensions
                  are loaded. In general, it's once per ui instance, but in command-server
                  and hgweb, this may be called more than once with the same ui.
                  """
                  for name, mod in extensions(ui):
                      hook = getattr(mod, 'uipopulate', None)
                      if not hook:
                          continue
                      try:
                          hook(ui)
                      except Exception as inst:
                          ui.traceback(force=True)
                          ui.warn(
                              _(b'*** failed to populate ui by extension %s: %s\n')
                              % (name, stringutil.forcebytestr(inst))
                          )
              def bind(func, *args):
                  """Partial function application
                  Returns a new function that is the partial application of args and kwargs
                  to func.  For example,
                      f(1, 2, bar=3) === bind(f, 1)(2, bar=3)"""
                  assert callable(func)
                  def closure(*a, **kw):
                      return func(*(args + a), **kw)
                  return closure
              def _updatewrapper(wrap, origfn, unboundwrapper):
                  '''Copy and add some useful attributes to wrapper'''
                  try:
                      wrap.__name__ = origfn.__name__
                  except AttributeError:
                      pass
                  wrap.__module__ = getattr(origfn, '__module__')
                  wrap.__doc__ = getattr(origfn, '__doc__')
                  wrap.__dict__.update(getattr(origfn, '__dict__', {}))
                  wrap._origfunc = origfn
                  wrap._unboundwrapper = unboundwrapper
              def wrapcommand(table, command, wrapper, synopsis=None, docstring=None):
                  '''Wrap the command named `command' in table
                  Replace command in the command table with wrapper. The wrapped command will
                  be inserted into the command table specified by the table argument.
                  The wrapper will be called like
                    wrapper(orig, *args, **kwargs)
                  where orig is the original (wrapped) function, and *args, **kwargs
                  are the arguments passed to it.
                  Optionally append to the command synopsis and docstring, used for help.
                  For example, if your extension wraps the ``bookmarks`` command to add the
                  flags ``--remote`` and ``--all`` you might call this function like so:
                    synopsis = ' [-a] [--remote]'
                    docstring = """
                    The ``remotenames`` extension adds the ``--remote`` and ``--all`` (``-a``)
                    flags to the bookmarks command. Either flag will show the remote bookmarks
                    known to the repository; ``--remote`` will also suppress the output of the
                    local bookmarks.
                    """
                    extensions.wrapcommand(commands.table, 'bookmarks', exbookmarks,
                                           synopsis, docstring)
                  '''
                  assert callable(wrapper)
                  aliases, entry = cmdutil.findcmd(command, table)
                  for alias, e in table.items():
                      if e is entry:
                          key = alias
                          break
                  origfn = entry[0]
                  wrap = functools.partial(
                      util.checksignature(wrapper), util.checksignature(origfn)
                  )
                  _updatewrapper(wrap, origfn, wrapper)
                  if docstring is not None:
                      wrap.__doc__ += docstring
                  newentry = list(entry)
                  newentry[0] = wrap
                  if synopsis is not None:
                      newentry[2] += synopsis
                  table[key] = tuple(newentry)
                  return entry
              def wrapfilecache(cls, propname, wrapper):
                  """Wraps a filecache property.
                  These can't be wrapped using the normal wrapfunction.
                  """
                  propname = pycompat.sysstr(propname)
                  assert callable(wrapper)
                  for currcls in cls.__mro__:
                      if propname in currcls.__dict__:
                          origfn = currcls.__dict__[propname].func
                          assert callable(origfn)
                          def wrap(*args, **kwargs):
                              return wrapper(origfn, *args, **kwargs)
                          currcls.__dict__[propname].func = wrap
                          break
                  if currcls is object:
                      raise AttributeError("type '%s' has no property '%s'" % (cls, propname))
              class wrappedfunction:
                  '''context manager for temporarily wrapping a function'''
                  def __init__(self, container, funcname, wrapper):
                      assert callable(wrapper)
                      if not isinstance(funcname, str):
                          msg = b"pass wrappedfunction target name as `str`, not `bytes`"
                          util.nouideprecwarn(msg, b"6.6", stacklevel=2)
                          funcname = pycompat.sysstr(funcname)
                      self._container = container
                      self._funcname = funcname
                      self._wrapper = wrapper
                  def __enter__(self):
                      wrapfunction(self._container, self._funcname, self._wrapper)
                  def __exit__(self, exctype, excvalue, traceback):
                      unwrapfunction(self._container, self._funcname, self._wrapper)
              def wrapfunction(container, funcname, wrapper):
                  """Wrap the function named funcname in container
                  Replace the funcname member in the given container with the specified
                  wrapper. The container is typically a module, class, or instance.
                  The wrapper will be called like
                    wrapper(orig, *args, **kwargs)
                  where orig is the original (wrapped) function, and *args, **kwargs
                  are the arguments passed to it.
                  Wrapping methods of the repository object is not recommended since
                  it conflicts with extensions that extend the repository by
                  subclassing. All extensions that need to extend methods of
                  localrepository should use this subclassing trick: namely,
                  reposetup() should look like
                    def reposetup(ui, repo):
                        class myrepo(repo.__class__):
                            def whatever(self, *args, **kwargs):
                                [...extension stuff...]
                                super(myrepo, self).whatever(*args, **kwargs)
                                [...extension stuff...]
                        repo.__class__ = myrepo
                  In general, combining wrapfunction() with subclassing does not
                  work. Since you cannot control what other extensions are loaded by
                  your end users, you should play nicely with others by using the
                  subclass trick.
                  """
                  assert callable(wrapper)
                  if not isinstance(funcname, str):
                      msg = b"pass wrapfunction target name as `str`, not `bytes`"
                      util.nouideprecwarn(msg, b"6.6", stacklevel=2)
                      funcname = pycompat.sysstr(funcname)
                  origfn = getattr(container, funcname)
                  assert callable(origfn)
                  if inspect.ismodule(container):
                      # origfn is not an instance or class method. "partial" can be used.
                      # "partial" won't insert a frame in traceback.
                      wrap = functools.partial(wrapper, origfn)
                  else:
                      # "partial" cannot be safely used. Emulate its effect by using "bind".
                      # The downside is one more frame in traceback.
                      wrap = bind(wrapper, origfn)
                  _updatewrapper(wrap, origfn, wrapper)
                  setattr(container, funcname, wrap)
                  return origfn
              def unwrapfunction(container, funcname, wrapper=None):
                  """undo wrapfunction
                  If wrappers is None, undo the last wrap. Otherwise removes the wrapper
                  from the chain of wrappers.
                  Return the removed wrapper.
                  Raise IndexError if wrapper is None and nothing to unwrap; ValueError if
                  wrapper is not None but is not found in the wrapper chain.
                  """
                  chain = getwrapperchain(container, funcname)
                  origfn = chain.pop()
                  if wrapper is None:
                      wrapper = chain[0]
                  chain.remove(wrapper)
                  setattr(container, funcname, origfn)
                  for w in reversed(chain):
                      wrapfunction(container, funcname, w)
                  return wrapper
              def getwrapperchain(container, funcname):
                  """get a chain of wrappers of a function
                  Return a list of functions: [newest wrapper, ..., oldest wrapper, origfunc]
                  The wrapper functions are the ones passed to wrapfunction, whose first
                  argument is origfunc.
                  """
                  result = []
                  fn = getattr(container, funcname)
                  while fn:
                      assert callable(fn)
                      result.append(getattr(fn, '_unboundwrapper', fn))
                      fn = getattr(fn, '_origfunc', None)
                  return result
              def _disabledpaths():
                  '''find paths of disabled extensions. returns a dict of {name: path}'''
                  import hgext
                  exts = {}
                  # The hgext might not have a __file__ attribute (e.g. in PyOxidizer) and
                  # it might not be on a filesystem even if it does.
                  if util.safehasattr(hgext, '__file__'):
                      extpath = os.path.dirname(
                          util.abspath(pycompat.fsencode(hgext.__file__))
                      )
                      try:
                          files = os.listdir(extpath)
                      except OSError:
                          pass
                      else:
                          for e in files:
                              if e.endswith(b'.py'):
                                  name = e.rsplit(b'.', 1)[0]
                                  path = os.path.join(extpath, e)
                              else:
                                  name = e
                                  path = os.path.join(extpath, e, b'__init__.py')
                                  if not os.path.exists(path):
                                      continue
                              if name in exts or name in _order or name == b'__init__':
                                  continue
                              exts[name] = path
                  for name, path in _disabledextensions.items():
                      # If no path was provided for a disabled extension (e.g. "color=!"),
                      # don't replace the path we already found by the scan above.
                      if path:
                          exts[name] = path
                  return exts
              def _moduledoc(file):
                  """return the top-level python documentation for the given file
                  Loosely inspired by pydoc.source_synopsis(), but rewritten to
                  handle triple quotes and to return the whole text instead of just
                  the synopsis"""
                  result = []
                  line = file.readline()
                  while line[:1] == b'#' or not line.strip():
                      line = file.readline()
                      if not line:
                          break
                  start = line[:3]
                  if start == b'"""' or start == b"'''":
                      line = line[3:]
                      while line:
                          if line.rstrip().endswith(start):
                              line = line.split(start)[0]
                              if line:
                                  result.append(line)
                              break
                          elif not line:
                              return None  # unmatched delimiter
                          result.append(line)
                          line = file.readline()
                  else:
                      return None
                  return b''.join(result)
              def _disabledhelp(path):
                  '''retrieve help synopsis of a disabled extension (without importing)'''
                  try:
                      with open(path, b'rb') as src:
                          doc = _moduledoc(src)
                  except IOError:
                      return
                  if doc:  # extracting localized synopsis
                      return gettext(doc)
                  else:
                      return _(b'(no help text available)')
              def disabled():
                  '''find disabled extensions from hgext. returns a dict of {name: desc}'''
                  try:
                      from hgext import __index__  # pytype: disable=import-error
                      return {
                          name: gettext(desc)
                          for name, desc in __index__.docs.items()
                          if name not in _order
                      }
                  except (ImportError, AttributeError):
                      pass
                  paths = _disabledpaths()
                  if not paths:
                      return {}
                  exts = {}
                  for name, path in paths.items():
                      doc = _disabledhelp(path)
                      if doc and name != b'__index__':
                          exts[name] = stringutil.firstline(doc)
                  return exts
              def disabled_help(name):
                  """Obtain the full help text for a disabled extension, or None."""
                  paths = _disabledpaths()
                  if name in paths:
                      return _disabledhelp(paths[name])
                  else:
                      try:
                          import hgext
                          from hgext import __index__  # pytype: disable=import-error
                          # The extensions are filesystem based, so either an error occurred
                          # or all are enabled.
                          if util.safehasattr(hgext, '__file__'):
                              return
                          if name in _order:  # enabled
                              return
                          else:
                              return gettext(__index__.docs.get(name))
                      except (ImportError, AttributeError):
                          pass
              def _walkcommand(node):
                  """Scan @command() decorators in the tree starting at node"""
                  todo = collections.deque([node])
                  while todo:
                      node = todo.popleft()
                      if not isinstance(node, ast.FunctionDef):
                          todo.extend(ast.iter_child_nodes(node))
                          continue
                      for d in node.decorator_list:
                          if not isinstance(d, ast.Call):
                              continue
                          if not isinstance(d.func, ast.Name):
                              continue
                          if d.func.id != 'command':
                              continue
                          yield d
              def _disabledcmdtable(path):
                  """Construct a dummy command table without loading the extension module
                  This may raise IOError or SyntaxError.
                  """
                  with open(path, b'rb') as src:
                      root = ast.parse(src.read(), path)
                  cmdtable = {}
+                 # Python 3.12 started removing Bytes and Str and deprecate harder
+                 use_constant = 'Bytes' not in vars(ast)
                  for node in _walkcommand(root):
                      if not node.args:
                          continue
                      a = node.args[0]
-                     if isinstance(a, ast.Str):
-                         name = pycompat.sysbytes(a.s)
-                     elif isinstance(a, ast.Bytes):
-                         name = a.s
-                     else:
-                         continue
+                     if use_constant:  # Valid since Python 3.8
+                         if isinstance(a, ast.Constant):
+                             if isinstance(a.value, str):
+                                 name = pycompat.sysbytes(a.value)
+                             elif isinstance(a.value, bytes):
+                                 name = a.value
+                             else:
+                                 continue
+                         else:
+                             continue
+                     else:  # Valid until 3.11
+                         if isinstance(a, ast.Str):
+                             name = pycompat.sysbytes(a.s)
+                         elif isinstance(a, ast.Bytes):
+                             name = a.s
+                         else:
+                             continue
                      cmdtable[name] = (None, [], b'')
                  return cmdtable
              def _finddisabledcmd(ui, cmd, name, path, strict):
                  try:
                      cmdtable = _disabledcmdtable(path)
                  except (IOError, SyntaxError):
                      return
                  try:
                      aliases, entry = cmdutil.findcmd(cmd, cmdtable, strict)
                  except (error.AmbiguousCommand, error.UnknownCommand):
                      return
                  for c in aliases:
                      if c.startswith(cmd):
                          cmd = c
                          break
                  else:
                      cmd = aliases[0]
                  doc = _disabledhelp(path)
                  return (cmd, name, doc)
              def disabledcmd(ui, cmd, strict=False):
                  """find cmd from disabled extensions without importing.
                  returns (cmdname, extname, doc)"""
                  paths = _disabledpaths()
                  if not paths:
                      raise error.UnknownCommand(cmd)
                  ext = None
                  # first, search for an extension with the same name as the command
                  path = paths.pop(cmd, None)
                  if path:
                      ext = _finddisabledcmd(ui, cmd, cmd, path, strict=strict)
                  if not ext:
                      # otherwise, interrogate each extension until there's a match
                      for name, path in paths.items():
                          ext = _finddisabledcmd(ui, cmd, name, path, strict=strict)
                          if ext:
                              break
                  if ext:
                      return ext
                  raise error.UnknownCommand(cmd)
              def enabled(shortname=True):
                  '''return a dict of {name: desc} of extensions'''
                  exts = {}
                  for ename, ext in extensions():
                      doc = gettext(ext.__doc__) or _(b'(no help text available)')
                      assert doc is not None  # help pytype
                      if shortname:
                          ename = ename.split(b'.')[-1]
                      exts[ename] = stringutil.firstline(doc).strip()
                  return exts
              def notloaded():
                  '''return short names of extensions that failed to load'''
                  return [name for name, mod in _extensions.items() if mod is None]
              def moduleversion(module):
                  '''return version information from given module as a string'''
                  if util.safehasattr(module, b'getversion') and callable(module.getversion):
                      try:
                          version = module.getversion()
                      except Exception:
                          version = b'unknown'
                  elif util.safehasattr(module, b'__version__'):
                      version = module.__version__
                  else:
                      version = b''
                  if isinstance(version, (list, tuple)):
                      version = b'.'.join(pycompat.bytestr(o) for o in version)
                  else:
                      # version data should be bytes, but not all extensions are ported
                      # to py3.
                      version = stringutil.forcebytestr(version)
                  return version
              def ismoduleinternal(module):
                  exttestedwith = getattr(module, 'testedwith', None)
                  return exttestedwith == b"ships-with-hg-core"

mercurial/repoview.py

0 +7 -5

              # repoview.py - Filtered view of a localrepo object
              #
              # Copyright 2012 Pierre-Yves David <pierre-yves.david@ens-lyon.org>
              #                Logilab SA        <contact@logilab.fr>
              #
              # This software may be used and distributed according to the terms of the
              # GNU General Public License version 2 or any later version.
              import copy
              import weakref
              from .i18n import _
              from .node import (
                  hex,
                  nullrev,
              )
              from .pycompat import (
                  delattr,
                  getattr,
                  setattr,
              )
              from . import (
                  error,
                  obsolete,
                  phases,
                  pycompat,
                  tags as tagsmod,
                  util,
              )
              from .utils import repoviewutil
              def hideablerevs(repo):
                  """Revision candidates to be hidden
                  This is a standalone function to allow extensions to wrap it.
                  Because we use the set of immutable changesets as a fallback subset in
                  branchmap (see mercurial.utils.repoviewutils.subsettable), you cannot set
                  "public" changesets as "hideable". Doing so would break multiple code
                  assertions and lead to crashes."""
                  obsoletes = obsolete.getrevs(repo, b'obsolete')
                  internals = repo._phasecache.getrevset(repo, phases.localhiddenphases)
                  internals = frozenset(internals)
                  return obsoletes | internals
              def pinnedrevs(repo):
                  """revisions blocking hidden changesets from being filtered"""
                  cl = repo.changelog
                  pinned = set()
                  pinned.update([par.rev() for par in repo[None].parents()])
                  pinned.update([cl.rev(bm) for bm in repo._bookmarks.values()])
                  tags = {}
                  tagsmod.readlocaltags(repo.ui, repo, tags, {})
                  if tags:
                      rev = cl.index.get_rev
                      pinned.update(rev(t[0]) for t in tags.values())
                      pinned.discard(None)
                  # Avoid cycle: mercurial.filemerge -> mercurial.templater ->
                  # mercurial.templatefuncs -> mercurial.revset -> mercurial.repoview ->
                  # mercurial.mergestate -> mercurial.filemerge
                  from . import mergestate
                  ms = mergestate.mergestate.read(repo)
                  if ms.active() and ms.unresolvedcount():
                      for node in (ms.local, ms.other):
                          rev = cl.index.get_rev(node)
                          if rev is not None:
                              pinned.add(rev)
                  return pinned
              def _revealancestors(pfunc, hidden, revs):
                  """reveals contiguous chains of hidden ancestors of 'revs' by removing them
                  from 'hidden'
                  - pfunc(r): a funtion returning parent of 'r',
                  - hidden: the (preliminary) hidden revisions, to be updated
                  - revs: iterable of revnum,
                  (Ancestors are revealed exclusively, i.e. the elements in 'revs' are
                  *not* revealed)
                  """
                  stack = list(revs)
                  while stack:
                      for p in pfunc(stack.pop()):
                          if p != nullrev and p in hidden:
                              hidden.remove(p)
                              stack.append(p)
              def computehidden(repo, visibilityexceptions=None):
                  """compute the set of hidden revision to filter
                  During most operation hidden should be filtered."""
                  assert not repo.changelog.filteredrevs
                  hidden = hideablerevs(repo)
                  if hidden:
                      hidden = set(hidden - pinnedrevs(repo))
                      if visibilityexceptions:
                          hidden -= visibilityexceptions
                      pfunc = repo.changelog.parentrevs
                      mutable = repo._phasecache.getrevset(repo, phases.mutablephases)
                      visible = mutable - hidden
                      _revealancestors(pfunc, hidden, visible)
                  return frozenset(hidden)
              def computesecret(repo, visibilityexceptions=None):
                  """compute the set of revision that can never be exposed through hgweb
                  Changeset in the secret phase (or above) should stay unaccessible."""
                  assert not repo.changelog.filteredrevs
                  secrets = repo._phasecache.getrevset(repo, phases.remotehiddenphases)
                  return frozenset(secrets)
              def computeunserved(repo, visibilityexceptions=None):
                  """compute the set of revision that should be filtered when used a server
                  Secret and hidden changeset should not pretend to be here."""
                  assert not repo.changelog.filteredrevs
                  # fast path in simple case to avoid impact of non optimised code
                  hiddens = filterrevs(repo, b'visible')
                  secrets = filterrevs(repo, b'served.hidden')
                  if secrets:
                      return frozenset(hiddens | secrets)
                  else:
                      return hiddens
              def computemutable(repo, visibilityexceptions=None):
                  assert not repo.changelog.filteredrevs
                  # fast check to avoid revset call on huge repo
                  if repo._phasecache.hasnonpublicphases(repo):
                      return frozenset(repo._phasecache.getrevset(repo, phases.mutablephases))
                  return frozenset()
              def computeimpactable(repo, visibilityexceptions=None):
                  """Everything impactable by mutable revision
                  The immutable filter still have some chance to get invalidated. This will
                  happen when:
                  - you garbage collect hidden changeset,
                  - public phase is moved backward,
                  - something is changed in the filtering (this could be fixed)
                  This filter out any mutable changeset and any public changeset that may be
                  impacted by something happening to a mutable revision.
                  This is achieved by filtered everything with a revision number equal or
                  higher than the first mutable changeset is filtered."""
                  assert not repo.changelog.filteredrevs
                  cl = repo.changelog
                  firstmutable = len(cl)
                  roots = repo._phasecache.nonpublicphaseroots(repo)
                  if roots:
                      firstmutable = min(firstmutable, min(cl.rev(r) for r in roots))
                  # protect from nullrev root
                  firstmutable = max(0, firstmutable)
                  return frozenset(range(firstmutable, len(cl)))
              # function to compute filtered set
              #
              # When adding a new filter you MUST update the table at:
              #     mercurial.utils.repoviewutil.subsettable
              # Otherwise your filter will have to recompute all its branches cache
              # from scratch (very slow).
              filtertable = {
                  b'visible': computehidden,
                  b'visible-hidden': computehidden,
                  b'served.hidden': computesecret,
                  b'served': computeunserved,
                  b'immutable': computemutable,
                  b'base': computeimpactable,
              }
              # set of filter level that will include the working copy parent no matter what.
              filter_has_wc = {b'visible', b'visible-hidden'}
              _basefiltername = list(filtertable)
              def extrafilter(ui):
                  """initialize extra filter and return its id
                  If extra filtering is configured, we make sure the associated filtered view
                  are declared and return the associated id.
                  """
                  frevs = ui.config(b'experimental', b'extra-filter-revs')
                  if frevs is None:
                      return None
                  fid = pycompat.sysbytes(util.DIGESTS[b'sha1'](frevs).hexdigest())[:12]
                  combine = lambda fname: fname + b'%' + fid
                  subsettable = repoviewutil.subsettable
                  if combine(b'base') not in filtertable:
-                     for name in _basefiltername:
+                     for base_name in _basefiltername:
-                         def extrafilteredrevs(repo, *args, **kwargs):
+                         def extrafilteredrevs(repo, *args, name=base_name, **kwargs):
                              baserevs = filtertable[name](repo, *args, **kwargs)
                              extrarevs = frozenset(repo.revs(frevs))
                              return baserevs | extrarevs
-                         filtertable[combine(name)] = extrafilteredrevs
-                         if name in subsettable:
-                             subsettable[combine(name)] = combine(subsettable[name])
+                         filtertable[combine(base_name)] = extrafilteredrevs
+                         if base_name in subsettable:
+                             subsettable[combine(base_name)] = combine(
+                                 subsettable[base_name]
+                             )
                  return fid
              def filterrevs(repo, filtername, visibilityexceptions=None):
                  """returns set of filtered revision for this filter name
                  visibilityexceptions is a set of revs which must are exceptions for
                  hidden-state and must be visible. They are dynamic and hence we should not
                  cache it's result"""
                  if filtername not in repo.filteredrevcache:
                      if repo.ui.configbool(b'devel', b'debug.repo-filters'):
                          msg = b'computing revision filter for "%s"'
                          msg %= filtername
                          if repo.ui.tracebackflag and repo.ui.debugflag:
                              # XXX use ui.write_err
                              util.debugstacktrace(
                                  msg,
                                  f=repo.ui._fout,
                                  otherf=repo.ui._ferr,
                                  prefix=b'debug.filters: ',
                              )
                          else:
                              repo.ui.debug(b'debug.filters: %s\n' % msg)
                      func = filtertable[filtername]
                      if visibilityexceptions:
                          return func(repo.unfiltered, visibilityexceptions)
                      repo.filteredrevcache[filtername] = func(repo.unfiltered())
                  return repo.filteredrevcache[filtername]
              def wrapchangelog(unfichangelog, filteredrevs):
                  cl = copy.copy(unfichangelog)
                  cl.filteredrevs = filteredrevs
                  class filteredchangelog(filteredchangelogmixin, cl.__class__):
                      pass
                  cl.__class__ = filteredchangelog
                  return cl
              class filteredchangelogmixin:
                  def tiprev(self):
                      """filtered version of revlog.tiprev"""
                      for i in range(len(self) - 1, -2, -1):
                          if i not in self.filteredrevs:
                              return i
                  def __contains__(self, rev):
                      """filtered version of revlog.__contains__"""
                      return 0 <= rev < len(self) and rev not in self.filteredrevs
                  def __iter__(self):
                      """filtered version of revlog.__iter__"""
                      def filterediter():
                          for i in range(len(self)):
                              if i not in self.filteredrevs:
                                  yield i
                      return filterediter()
                  def revs(self, start=0, stop=None):
                      """filtered version of revlog.revs"""
                      for i in super(filteredchangelogmixin, self).revs(start, stop):
                          if i not in self.filteredrevs:
                              yield i
                  def _checknofilteredinrevs(self, revs):
                      """raise the appropriate error if 'revs' contains a filtered revision
                      This returns a version of 'revs' to be used thereafter by the caller.
                      In particular, if revs is an iterator, it is converted into a set.
                      """
                      safehasattr = util.safehasattr
                      if safehasattr(revs, '__next__'):
                          # Note that inspect.isgenerator() is not true for iterators,
                          revs = set(revs)
                      filteredrevs = self.filteredrevs
                      if safehasattr(revs, 'first'):  # smartset
                          offenders = revs & filteredrevs
                      else:
                          offenders = filteredrevs.intersection(revs)
                      for rev in offenders:
                          raise error.FilteredIndexError(rev)
                      return revs
                  def headrevs(self, revs=None):
                      if revs is None:
                          try:
                              return self.index.headrevsfiltered(self.filteredrevs)
                          # AttributeError covers non-c-extension environments and
                          # old c extensions without filter handling.
                          except AttributeError:
                              return self._headrevs()
                      revs = self._checknofilteredinrevs(revs)
                      return super(filteredchangelogmixin, self).headrevs(revs)
                  def strip(self, *args, **kwargs):
                      # XXX make something better than assert
                      # We can't expect proper strip behavior if we are filtered.
                      assert not self.filteredrevs
                      super(filteredchangelogmixin, self).strip(*args, **kwargs)
                  def rev(self, node):
                      """filtered version of revlog.rev"""
                      r = super(filteredchangelogmixin, self).rev(node)
                      if r in self.filteredrevs:
                          raise error.FilteredLookupError(
                              hex(node), self.display_id, _(b'filtered node')
                          )
                      return r
                  def node(self, rev):
                      """filtered version of revlog.node"""
                      if rev in self.filteredrevs:
                          raise error.FilteredIndexError(rev)
                      return super(filteredchangelogmixin, self).node(rev)
                  def linkrev(self, rev):
                      """filtered version of revlog.linkrev"""
                      if rev in self.filteredrevs:
                          raise error.FilteredIndexError(rev)
                      return super(filteredchangelogmixin, self).linkrev(rev)
                  def parentrevs(self, rev):
                      """filtered version of revlog.parentrevs"""
                      if rev in self.filteredrevs:
                          raise error.FilteredIndexError(rev)
                      return super(filteredchangelogmixin, self).parentrevs(rev)
                  def flags(self, rev):
                      """filtered version of revlog.flags"""
                      if rev in self.filteredrevs:
                          raise error.FilteredIndexError(rev)
                      return super(filteredchangelogmixin, self).flags(rev)
              class repoview:
                  """Provide a read/write view of a repo through a filtered changelog
                  This object is used to access a filtered version of a repository without
                  altering the original repository object itself. We can not alter the
                  original object for two main reasons:
                  - It prevents the use of a repo with multiple filters at the same time. In
                    particular when multiple threads are involved.
                  - It makes scope of the filtering harder to control.
                  This object behaves very closely to the original repository. All attribute
                  operations are done on the original repository:
                  - An access to `repoview.someattr` actually returns `repo.someattr`,
                  - A write to `repoview.someattr` actually sets value of `repo.someattr`,
                  - A deletion of `repoview.someattr` actually drops `someattr`
                    from `repo.__dict__`.
                  The only exception is the `changelog` property. It is overridden to return
                  a (surface) copy of `repo.changelog` with some revisions filtered. The
                  `filtername` attribute of the view control the revisions that need to be
                  filtered.  (the fact the changelog is copied is an implementation detail).
                  Unlike attributes, this object intercepts all method calls. This means that
                  all methods are run on the `repoview` object with the filtered `changelog`
                  property. For this purpose the simple `repoview` class must be mixed with
                  the actual class of the repository. This ensures that the resulting
                  `repoview` object have the very same methods than the repo object. This
                  leads to the property below.
                      repoview.method() --> repo.__class__.method(repoview)
                  The inheritance has to be done dynamically because `repo` can be of any
                  subclasses of `localrepo`. Eg: `bundlerepo` or `statichttprepo`.
                  """
                  def __init__(self, repo, filtername, visibilityexceptions=None):
                      object.__setattr__(self, '_unfilteredrepo', repo)
                      object.__setattr__(self, 'filtername', filtername)
                      object.__setattr__(self, '_clcachekey', None)
                      object.__setattr__(self, '_clcache', None)
                      # revs which are exceptions and must not be hidden
                      object.__setattr__(self, '_visibilityexceptions', visibilityexceptions)
                  # not a propertycache on purpose we shall implement a proper cache later
                  @property
                  def changelog(self):
                      """return a filtered version of the changeset
                      this changelog must not be used for writing"""
                      # some cache may be implemented later
                      unfi = self._unfilteredrepo
                      unfichangelog = unfi.changelog
                      # bypass call to changelog.method
                      unfiindex = unfichangelog.index
                      unfilen = len(unfiindex)
                      unfinode = unfiindex[unfilen - 1][7]
                      with util.timedcm('repo filter for %s', self.filtername):
                          revs = filterrevs(unfi, self.filtername, self._visibilityexceptions)
                      cl = self._clcache
                      newkey = (unfilen, unfinode, hash(revs), unfichangelog._delayed)
                      # if cl.index is not unfiindex, unfi.changelog would be
                      # recreated, and our clcache refers to garbage object
                      if cl is not None and (
                          cl.index is not unfiindex or newkey != self._clcachekey
                      ):
                          cl = None
                      # could have been made None by the previous if
                      if cl is None:
                          # Only filter if there's something to filter
                          cl = wrapchangelog(unfichangelog, revs) if revs else unfichangelog
                          object.__setattr__(self, '_clcache', cl)
                          object.__setattr__(self, '_clcachekey', newkey)
                      return cl
                  def unfiltered(self):
                      """Return an unfiltered version of a repo"""
                      return self._unfilteredrepo
                  def filtered(self, name, visibilityexceptions=None):
                      """Return a filtered version of a repository"""
                      if name == self.filtername and not visibilityexceptions:
                          return self
                      return self.unfiltered().filtered(name, visibilityexceptions)
                  def __repr__(self):
                      return '<%s:%s %r>' % (
                          self.__class__.__name__,
                          pycompat.sysstr(self.filtername),
                          self.unfiltered(),
                      )
                  # everything access are forwarded to the proxied repo
                  def __getattr__(self, attr):
                      return getattr(self._unfilteredrepo, attr)
                  def __setattr__(self, attr, value):
                      return setattr(self._unfilteredrepo, attr, value)
                  def __delattr__(self, attr):
                      return delattr(self._unfilteredrepo, attr)
              # Dynamically created classes introduce memory cycles via __mro__. See
              # https://bugs.python.org/issue17950.
              # This need of the garbage collector can turn into memory leak in
              # Python <3.4, which is the first version released with PEP 442.
              _filteredrepotypes = weakref.WeakKeyDictionary()
              def newtype(base):
                  """Create a new type with the repoview mixin and the given base class"""
                  ref = _filteredrepotypes.get(base)
                  if ref is not None:
                      cls = ref()
                      if cls is not None:
                          return cls
                  class filteredrepo(repoview, base):
                      pass
                  _filteredrepotypes[base] = weakref.ref(filteredrepo)
                  # do not reread from weakref to be 100% sure not to return None
                  return filteredrepo

mercurial/revlog.py

0 +5 -2

              # revlog.py - storage back-end for mercurial
              # coding: utf8
              #
              # Copyright 2005-2007 Olivia Mackall <olivia@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.
              """Storage back-end for Mercurial.
              This provides efficient delta storage with O(1) retrieve and append
              and O(changes) merge between branches.
              """
              import binascii
              import collections
              import contextlib
              import io
              import os
              import struct
              import weakref
              import zlib
              # import stuff from node for others to import from revlog
              from .node import (
                  bin,
                  hex,
                  nullrev,
                  sha1nodeconstants,
                  short,
                  wdirrev,
              )
              from .i18n import _
              from .pycompat import getattr
              from .revlogutils.constants import (
                  ALL_KINDS,
                  CHANGELOGV2,
                  COMP_MODE_DEFAULT,
                  COMP_MODE_INLINE,
                  COMP_MODE_PLAIN,
                  DELTA_BASE_REUSE_NO,
                  DELTA_BASE_REUSE_TRY,
                  ENTRY_RANK,
                  FEATURES_BY_VERSION,
                  FLAG_GENERALDELTA,
                  FLAG_INLINE_DATA,
                  INDEX_HEADER,
                  KIND_CHANGELOG,
                  KIND_FILELOG,
                  RANK_UNKNOWN,
                  REVLOGV0,
                  REVLOGV1,
                  REVLOGV1_FLAGS,
                  REVLOGV2,
                  REVLOGV2_FLAGS,
                  REVLOG_DEFAULT_FLAGS,
                  REVLOG_DEFAULT_FORMAT,
                  REVLOG_DEFAULT_VERSION,
                  SUPPORTED_FLAGS,
              )
              from .revlogutils.flagutil import (
                  REVIDX_DEFAULT_FLAGS,
                  REVIDX_ELLIPSIS,
                  REVIDX_EXTSTORED,
                  REVIDX_FLAGS_ORDER,
                  REVIDX_HASCOPIESINFO,
                  REVIDX_ISCENSORED,
                  REVIDX_RAWTEXT_CHANGING_FLAGS,
              )
              from .thirdparty import attr
              from . import (
                  ancestor,
                  dagop,
                  error,
                  mdiff,
                  policy,
                  pycompat,
                  revlogutils,
                  templatefilters,
                  util,
              )
              from .interfaces import (
                  repository,
                  util as interfaceutil,
              )
              from .revlogutils import (
                  deltas as deltautil,
                  docket as docketutil,
                  flagutil,
                  nodemap as nodemaputil,
                  randomaccessfile,
                  revlogv0,
                  rewrite,
                  sidedata as sidedatautil,
              )
              from .utils import (
                  storageutil,
                  stringutil,
              )
              # blanked usage of all the name to prevent pyflakes constraints
              # We need these name available in the module for extensions.
              REVLOGV0
              REVLOGV1
              REVLOGV2
              CHANGELOGV2
              FLAG_INLINE_DATA
              FLAG_GENERALDELTA
              REVLOG_DEFAULT_FLAGS
              REVLOG_DEFAULT_FORMAT
              REVLOG_DEFAULT_VERSION
              REVLOGV1_FLAGS
              REVLOGV2_FLAGS
              REVIDX_ISCENSORED
              REVIDX_ELLIPSIS
              REVIDX_HASCOPIESINFO
              REVIDX_EXTSTORED
              REVIDX_DEFAULT_FLAGS
              REVIDX_FLAGS_ORDER
              REVIDX_RAWTEXT_CHANGING_FLAGS
              parsers = policy.importmod('parsers')
              rustancestor = policy.importrust('ancestor')
              rustdagop = policy.importrust('dagop')
              rustrevlog = policy.importrust('revlog')
              # Aliased for performance.
              _zlibdecompress = zlib.decompress
              # max size of inline data embedded into a revlog
              _maxinline = 131072
              # Flag processors for REVIDX_ELLIPSIS.
              def ellipsisreadprocessor(rl, text):
                  return text, False
              def ellipsiswriteprocessor(rl, text):
                  return text, False
              def ellipsisrawprocessor(rl, text):
                  return False
              ellipsisprocessor = (
                  ellipsisreadprocessor,
                  ellipsiswriteprocessor,
                  ellipsisrawprocessor,
              )
              def _verify_revision(rl, skipflags, state, node):
                  """Verify the integrity of the given revlog ``node`` while providing a hook
                  point for extensions to influence the operation."""
                  if skipflags:
                      state[b'skipread'].add(node)
                  else:
                      # Side-effect: read content and verify hash.
                      rl.revision(node)
              # True if a fast implementation for persistent-nodemap is available
              #
              # We also consider we have a "fast" implementation in "pure" python because
              # people using pure don't really have performance consideration (and a
              # wheelbarrow of other slowness source)
              HAS_FAST_PERSISTENT_NODEMAP = rustrevlog is not None or util.safehasattr(
                  parsers, 'BaseIndexObject'
              )
              @interfaceutil.implementer(repository.irevisiondelta)
              @attr.s(slots=True)
              class revlogrevisiondelta:
                  node = attr.ib()
                  p1node = attr.ib()
                  p2node = attr.ib()
                  basenode = attr.ib()
                  flags = attr.ib()
                  baserevisionsize = attr.ib()
                  revision = attr.ib()
                  delta = attr.ib()
                  sidedata = attr.ib()
                  protocol_flags = attr.ib()
                  linknode = attr.ib(default=None)
              @interfaceutil.implementer(repository.iverifyproblem)
              @attr.s(frozen=True)
              class revlogproblem:
                  warning = attr.ib(default=None)
                  error = attr.ib(default=None)
                  node = attr.ib(default=None)
              def parse_index_v1(data, inline):
                  # call the C implementation to parse the index data
                  index, cache = parsers.parse_index2(data, inline)
                  return index, cache
              def parse_index_v2(data, inline):
                  # call the C implementation to parse the index data
                  index, cache = parsers.parse_index2(data, inline, format=REVLOGV2)
                  return index, cache
              def parse_index_cl_v2(data, inline):
                  # call the C implementation to parse the index data
                  index, cache = parsers.parse_index2(data, inline, format=CHANGELOGV2)
                  return index, cache
              if util.safehasattr(parsers, 'parse_index_devel_nodemap'):
                  def parse_index_v1_nodemap(data, inline):
                      index, cache = parsers.parse_index_devel_nodemap(data, inline)
                      return index, cache
              else:
                  parse_index_v1_nodemap = None
              def parse_index_v1_mixed(data, inline):
                  index, cache = parse_index_v1(data, inline)
                  return rustrevlog.MixedIndex(index), cache
              # corresponds to uncompressed length of indexformatng (2 gigs, 4-byte
              # signed integer)
              _maxentrysize = 0x7FFFFFFF
              FILE_TOO_SHORT_MSG = _(
                  b'cannot read from revlog %s;'
                  b'  expected %d bytes from offset %d, data size is %d'
              )
              hexdigits = b'0123456789abcdefABCDEF'
              class revlog:
                  """
                  the underlying revision storage object
                  A revlog consists of two parts, an index and the revision data.
                  The index is a file with a fixed record size containing
                  information on each revision, including its nodeid (hash), the
                  nodeids of its parents, the position and offset of its data within
                  the data file, and the revision it's based on. Finally, each entry
                  contains a linkrev entry that can serve as a pointer to external
                  data.
                  The revision data itself is a linear collection of data chunks.
                  Each chunk represents a revision and is usually represented as a
                  delta against the previous chunk. To bound lookup time, runs of
                  deltas are limited to about 2 times the length of the original
                  version data. This makes retrieval of a version proportional to
                  its size, or O(1) relative to the number of revisions.
                  Both pieces of the revlog are written to in an append-only
                  fashion, which means we never need to rewrite a file to insert or
                  remove data, and can use some simple techniques to avoid the need
                  for locking while reading.
                  If checkambig, indexfile is opened with checkambig=True at
                  writing, to avoid file stat ambiguity.
                  If mmaplargeindex is True, and an mmapindexthreshold is set, the
                  index will be mmapped rather than read if it is larger than the
                  configured threshold.
                  If censorable is True, the revlog can have censored revisions.
                  If `upperboundcomp` is not None, this is the expected maximal gain from
                  compression for the data content.
                  `concurrencychecker` is an optional function that receives 3 arguments: a
                  file handle, a filename, and an expected position. It should check whether
                  the current position in the file handle is valid, and log/warn/fail (by
                  raising).
                  See mercurial/revlogutils/contants.py for details about the content of an
                  index entry.
                  """
                  _flagserrorclass = error.RevlogError
                  @staticmethod
                  def is_inline_index(header_bytes):
                      header = INDEX_HEADER.unpack(header_bytes)[0]
                      _format_flags = header & ~0xFFFF
                      _format_version = header & 0xFFFF
                      features = FEATURES_BY_VERSION[_format_version]
                      return features[b'inline'](_format_flags)
                  def __init__(
                      self,
                      opener,
                      target,
                      radix,
                      postfix=None,  # only exist for `tmpcensored` now
                      checkambig=False,
                      mmaplargeindex=False,
                      censorable=False,
                      upperboundcomp=None,
                      persistentnodemap=False,
                      concurrencychecker=None,
                      trypending=False,
                      try_split=False,
                      canonical_parent_order=True,
                  ):
                      """
                      create a revlog object
                      opener is a function that abstracts the file opening operation
                      and can be used to implement COW semantics or the like.
                      `target`: a (KIND, ID) tuple that identify the content stored in
                      this revlog. It help the rest of the code to understand what the revlog
                      is about without having to resort to heuristic and index filename
                      analysis. Note: that this must be reliably be set by normal code, but
                      that test, debug, or performance measurement code might not set this to
                      accurate value.
                      """
                      self.upperboundcomp = upperboundcomp
                      self.radix = radix
                      self._docket_file = None
                      self._indexfile = None
                      self._datafile = None
                      self._sidedatafile = None
                      self._nodemap_file = None
                      self.postfix = postfix
                      self._trypending = trypending
                      self._try_split = try_split
                      self.opener = opener
                      if persistentnodemap:
                          self._nodemap_file = nodemaputil.get_nodemap_file(self)
                      assert target[0] in ALL_KINDS
                      assert len(target) == 2
                      self.target = target
                      #  When True, indexfile is opened with checkambig=True at writing, to
                      #  avoid file stat ambiguity.
                      self._checkambig = checkambig
                      self._mmaplargeindex = mmaplargeindex
                      self._censorable = censorable
                      # 3-tuple of (node, rev, text) for a raw revision.
                      self._revisioncache = None
                      # Maps rev to chain base rev.
                      self._chainbasecache = util.lrucachedict(100)
                      # 2-tuple of (offset, data) of raw data from the revlog at an offset.
                      self._chunkcache = (0, b'')
                      # How much data to read and cache into the raw revlog data cache.
                      self._chunkcachesize = 65536
                      self._maxchainlen = None
                      self._deltabothparents = True
                      self._candidate_group_chunk_size = 0
                      self._debug_delta = False
                      self.index = None
                      self._docket = None
                      self._nodemap_docket = None
                      # Mapping of partial identifiers to full nodes.
                      self._pcache = {}
                      # Mapping of revision integer to full node.
                      self._compengine = b'zlib'
                      self._compengineopts = {}
                      self._maxdeltachainspan = -1
                      self._withsparseread = False
                      self._sparserevlog = False
                      self.hassidedata = False
                      self._srdensitythreshold = 0.50
                      self._srmingapsize = 262144
                      # other optionnals features
                      # might remove rank configuration once the computation has no impact
                      self._compute_rank = False
                      # Make copy of flag processors so each revlog instance can support
                      # custom flags.
                      self._flagprocessors = dict(flagutil.flagprocessors)
                      # 3-tuple of file handles being used for active writing.
                      self._writinghandles = None
                      # prevent nesting of addgroup
                      self._adding_group = None
                      self._loadindex()
                      self._concurrencychecker = concurrencychecker
                      # parent order is supposed to be semantically irrelevant, so we
                      # normally resort parents to ensure that the first parent is non-null,
                      # if there is a non-null parent at all.
                      # filelog abuses the parent order as flag to mark some instances of
                      # meta-encoded files, so allow it to disable this behavior.
                      self.canonical_parent_order = canonical_parent_order
                  def _init_opts(self):
                      """process options (from above/config) to setup associated default revlog mode
                      These values might be affected when actually reading on disk information.
                      The relevant values are returned for use in _loadindex().
                      * newversionflags:
                          version header to use if we need to create a new revlog
                      * mmapindexthreshold:
                          minimal index size for start to use mmap
                      * force_nodemap:
                          force the usage of a "development" version of the nodemap code
                      """
                      mmapindexthreshold = None
                      opts = self.opener.options
                      if b'changelogv2' in opts and self.revlog_kind == KIND_CHANGELOG:
                          new_header = CHANGELOGV2
                          self._compute_rank = opts.get(b'changelogv2.compute-rank', True)
                      elif b'revlogv2' in opts:
                          new_header = REVLOGV2
                      elif b'revlogv1' in opts:
                          new_header = REVLOGV1 | FLAG_INLINE_DATA
                          if b'generaldelta' in opts:
                              new_header |= FLAG_GENERALDELTA
                      elif b'revlogv0' in self.opener.options:
                          new_header = REVLOGV0
                      else:
                          new_header = REVLOG_DEFAULT_VERSION
                      if b'chunkcachesize' in opts:
                          self._chunkcachesize = opts[b'chunkcachesize']
                      if b'maxchainlen' in opts:
                          self._maxchainlen = opts[b'maxchainlen']
                      if b'deltabothparents' in opts:
                          self._deltabothparents = opts[b'deltabothparents']
                      dps_cgds = opts.get(b'delta-parent-search.candidate-group-chunk-size')
                      if dps_cgds:
                          self._candidate_group_chunk_size = dps_cgds
                      self._lazydelta = bool(opts.get(b'lazydelta', True))
                      self._lazydeltabase = False
                      if self._lazydelta:
                          self._lazydeltabase = bool(opts.get(b'lazydeltabase', False))
                      if b'debug-delta' in opts:
                          self._debug_delta = opts[b'debug-delta']
                      if b'compengine' in opts:
                          self._compengine = opts[b'compengine']
                      if b'zlib.level' in opts:
                          self._compengineopts[b'zlib.level'] = opts[b'zlib.level']
                      if b'zstd.level' in opts:
                          self._compengineopts[b'zstd.level'] = opts[b'zstd.level']
                      if b'maxdeltachainspan' in opts:
                          self._maxdeltachainspan = opts[b'maxdeltachainspan']
                      if self._mmaplargeindex and b'mmapindexthreshold' in opts:
                          mmapindexthreshold = opts[b'mmapindexthreshold']
                      self._sparserevlog = bool(opts.get(b'sparse-revlog', False))
                      withsparseread = bool(opts.get(b'with-sparse-read', False))
                      # sparse-revlog forces sparse-read
                      self._withsparseread = self._sparserevlog or withsparseread
                      if b'sparse-read-density-threshold' in opts:
                          self._srdensitythreshold = opts[b'sparse-read-density-threshold']
                      if b'sparse-read-min-gap-size' in opts:
                          self._srmingapsize = opts[b'sparse-read-min-gap-size']
                      if opts.get(b'enableellipsis'):
                          self._flagprocessors[REVIDX_ELLIPSIS] = ellipsisprocessor
                      # revlog v0 doesn't have flag processors
                      for flag, processor in opts.get(b'flagprocessors', {}).items():
                          flagutil.insertflagprocessor(flag, processor, self._flagprocessors)
                      if self._chunkcachesize <= 0:
                          raise error.RevlogError(
                              _(b'revlog chunk cache size %r is not greater than 0')
                              % self._chunkcachesize
                          )
                      elif self._chunkcachesize & (self._chunkcachesize - 1):
                          raise error.RevlogError(
                              _(b'revlog chunk cache size %r is not a power of 2')
                              % self._chunkcachesize
                          )
                      force_nodemap = opts.get(b'devel-force-nodemap', False)
                      return new_header, mmapindexthreshold, force_nodemap
                  def _get_data(self, filepath, mmap_threshold, size=None):
                      """return a file content with or without mmap
                      If the file is missing return the empty string"""
                      try:
                          with self.opener(filepath) as fp:
                              if mmap_threshold is not None:
                                  file_size = self.opener.fstat(fp).st_size
                                  if file_size >= mmap_threshold:
                                      if size is not None:
                                          # avoid potentiel mmap crash
                                          size = min(file_size, size)
                                      # TODO: should .close() to release resources without
                                      # relying on Python GC
                                      if size is None:
                                          return util.buffer(util.mmapread(fp))
                                      else:
                                          return util.buffer(util.mmapread(fp, size))
                              if size is None:
                                  return fp.read()
                              else:
                                  return fp.read(size)
                      except FileNotFoundError:
                          return b''
                  def get_streams(self, max_linkrev, force_inline=False):
                      n = len(self)
                      index = self.index
                      while n > 0:
                          linkrev = index[n - 1][4]
                          if linkrev < max_linkrev:
                              break
                          # note: this loop will rarely go through multiple iterations, since
                          # it only traverses commits created during the current streaming
                          # pull operation.
                          #
                          # If this become a problem, using a binary search should cap the
                          # runtime of this.
                          n = n - 1
                      if n == 0:
                          # no data to send
                          return []
                      index_size = n * index.entry_size
                      data_size = self.end(n - 1)
                      # XXX we might have been split (or stripped) since the object
                      # initialization, We need to close this race too, but having a way to
                      # pre-open the file we feed to the revlog and never closing them before
                      # we are done streaming.
                      if self._inline:
                          def get_stream():
                              with self._indexfp() as fp:
                                  yield None
                                  size = index_size + data_size
                                  if size <= 65536:
                                      yield fp.read(size)
                                  else:
                                      yield from util.filechunkiter(fp, limit=size)
                          inline_stream = get_stream()
                          next(inline_stream)
                          return [
                              (self._indexfile, inline_stream, index_size + data_size),
                          ]
                      elif force_inline:
                          def get_stream():
                              with self._datafp() as fp_d:
                                  yield None
                                  for rev in range(n):
                                      idx = self.index.entry_binary(rev)
                                      if rev == 0 and self._docket is None:
                                          # re-inject the inline flag
                                          header = self._format_flags
                                          header |= self._format_version
                                          header |= FLAG_INLINE_DATA
                                          header = self.index.pack_header(header)
                                          idx = header + idx
                                      yield idx
                                      yield self._getsegmentforrevs(rev, rev, df=fp_d)[1]
                          inline_stream = get_stream()
                          next(inline_stream)
                          return [
                              (self._indexfile, inline_stream, index_size + data_size),
                          ]
                      else:
                          def get_index_stream():
                              with self._indexfp() as fp:
                                  yield None
                                  if index_size <= 65536:
                                      yield fp.read(index_size)
                                  else:
                                      yield from util.filechunkiter(fp, limit=index_size)
                          def get_data_stream():
                              with self._datafp() as fp:
                                  yield None
                                  if data_size <= 65536:
                                      yield fp.read(data_size)
                                  else:
                                      yield from util.filechunkiter(fp, limit=data_size)
                          index_stream = get_index_stream()
                          next(index_stream)
                          data_stream = get_data_stream()
                          next(data_stream)
                          return [
                              (self._datafile, data_stream, data_size),
                              (self._indexfile, index_stream, index_size),
                          ]
                  def _loadindex(self, docket=None):
                      new_header, mmapindexthreshold, force_nodemap = self._init_opts()
                      if self.postfix is not None:
                          entry_point = b'%s.i.%s' % (self.radix, self.postfix)
                      elif self._trypending and self.opener.exists(b'%s.i.a' % self.radix):
                          entry_point = b'%s.i.a' % self.radix
                      elif self._try_split and self.opener.exists(self._split_index_file):
                          entry_point = self._split_index_file
                      else:
                          entry_point = b'%s.i' % self.radix
                      if docket is not None:
                          self._docket = docket
                          self._docket_file = entry_point
                      else:
                          self._initempty = True
                          entry_data = self._get_data(entry_point, mmapindexthreshold)
                          if len(entry_data) > 0:
                              header = INDEX_HEADER.unpack(entry_data[:4])[0]
                              self._initempty = False
                          else:
                              header = new_header
                          self._format_flags = header & ~0xFFFF
                          self._format_version = header & 0xFFFF
                          supported_flags = SUPPORTED_FLAGS.get(self._format_version)
                          if supported_flags is None:
                              msg = _(b'unknown version (%d) in revlog %s')
                              msg %= (self._format_version, self.display_id)
                              raise error.RevlogError(msg)
                          elif self._format_flags & ~supported_flags:
                              msg = _(b'unknown flags (%#04x) in version %d revlog %s')
                              display_flag = self._format_flags >> 16
                              msg %= (display_flag, self._format_version, self.display_id)
                              raise error.RevlogError(msg)
                          features = FEATURES_BY_VERSION[self._format_version]
                          self._inline = features[b'inline'](self._format_flags)
                          self._generaldelta = features[b'generaldelta'](self._format_flags)
                          self.hassidedata = features[b'sidedata']
                          if not features[b'docket']:
                              self._indexfile = entry_point
                              index_data = entry_data
                          else:
                              self._docket_file = entry_point
                              if self._initempty:
                                  self._docket = docketutil.default_docket(self, header)
                              else:
                                  self._docket = docketutil.parse_docket(
                                      self, entry_data, use_pending=self._trypending
                                  )
                      if self._docket is not None:
                          self._indexfile = self._docket.index_filepath()
                          index_data = b''
                          index_size = self._docket.index_end
                          if index_size > 0:
                              index_data = self._get_data(
                                  self._indexfile, mmapindexthreshold, size=index_size
                              )
                              if len(index_data) < index_size:
                                  msg = _(b'too few index data for %s: got %d, expected %d')
                                  msg %= (self.display_id, len(index_data), index_size)
                                  raise error.RevlogError(msg)
                          self._inline = False
                          # generaldelta implied by version 2 revlogs.
                          self._generaldelta = True
                          # the logic for persistent nodemap will be dealt with within the
                          # main docket, so disable it for now.
                          self._nodemap_file = None
                      if self._docket is not None:
                          self._datafile = self._docket.data_filepath()
                          self._sidedatafile = self._docket.sidedata_filepath()
                      elif self.postfix is None:
                          self._datafile = b'%s.d' % self.radix
                      else:
                          self._datafile = b'%s.d.%s' % (self.radix, self.postfix)
                      self.nodeconstants = sha1nodeconstants
                      self.nullid = self.nodeconstants.nullid
                      # sparse-revlog can't be on without general-delta (issue6056)
                      if not self._generaldelta:
                          self._sparserevlog = False
                      self._storedeltachains = True
                      devel_nodemap = (
                          self._nodemap_file
                          and force_nodemap
                          and parse_index_v1_nodemap is not None
                      )
                      use_rust_index = False
                      if rustrevlog is not None:
                          if self._nodemap_file is not None:
                              use_rust_index = True
                          else:
                              use_rust_index = self.opener.options.get(b'rust.index')
                      self._parse_index = parse_index_v1
                      if self._format_version == REVLOGV0:
                          self._parse_index = revlogv0.parse_index_v0
                      elif self._format_version == REVLOGV2:
                          self._parse_index = parse_index_v2
                      elif self._format_version == CHANGELOGV2:
                          self._parse_index = parse_index_cl_v2
                      elif devel_nodemap:
                          self._parse_index = parse_index_v1_nodemap
                      elif use_rust_index:
                          self._parse_index = parse_index_v1_mixed
                      try:
                          d = self._parse_index(index_data, self._inline)
                          index, chunkcache = d
                          use_nodemap = (
                              not self._inline
                              and self._nodemap_file is not None
                              and util.safehasattr(index, 'update_nodemap_data')
                          )
                          if use_nodemap:
                              nodemap_data = nodemaputil.persisted_data(self)
                              if nodemap_data is not None:
                                  docket = nodemap_data[0]
                                  if (
                                      len(d[0]) > docket.tip_rev
                                      and d[0][docket.tip_rev][7] == docket.tip_node
                                  ):
                                      # no changelog tampering
                                      self._nodemap_docket = docket
                                      index.update_nodemap_data(*nodemap_data)
                      except (ValueError, IndexError):
                          raise error.RevlogError(
                              _(b"index %s is corrupted") % self.display_id
                          )
                      self.index = index
                      self._segmentfile = randomaccessfile.randomaccessfile(
                          self.opener,
                          (self._indexfile if self._inline else self._datafile),
                          self._chunkcachesize,
                          chunkcache,
                      )
                      self._segmentfile_sidedata = randomaccessfile.randomaccessfile(
                          self.opener,
                          self._sidedatafile,
                          self._chunkcachesize,
                      )
                      # revnum -> (chain-length, sum-delta-length)
                      self._chaininfocache = util.lrucachedict(500)
                      # revlog header -> revlog compressor
                      self._decompressors = {}
                  def get_revlog(self):
                      """simple function to mirror API of other not-really-revlog API"""
                      return self
                  @util.propertycache
                  def revlog_kind(self):
                      return self.target[0]
                  @util.propertycache
                  def display_id(self):
                      """The public facing "ID" of the revlog that we use in message"""
                      if self.revlog_kind == KIND_FILELOG:
                          # Reference the file without the "data/" prefix, so it is familiar
                          # to the user.
                          return self.target[1]
                      else:
                          return self.radix
                  def _get_decompressor(self, t):
                      try:
                          compressor = self._decompressors[t]
                      except KeyError:
                          try:
                              engine = util.compengines.forrevlogheader(t)
                              compressor = engine.revlogcompressor(self._compengineopts)
                              self._decompressors[t] = compressor
                          except KeyError:
                              raise error.RevlogError(
                                  _(b'unknown compression type %s') % binascii.hexlify(t)
                              )
                      return compressor
                  @util.propertycache
                  def _compressor(self):
                      engine = util.compengines[self._compengine]
                      return engine.revlogcompressor(self._compengineopts)
                  @util.propertycache
                  def _decompressor(self):
                      """the default decompressor"""
                      if self._docket is None:
                          return None
                      t = self._docket.default_compression_header
                      c = self._get_decompressor(t)
                      return c.decompress
                  def _indexfp(self):
                      """file object for the revlog's index file"""
                      return self.opener(self._indexfile, mode=b"r")
                  def __index_write_fp(self):
                      # You should not use this directly and use `_writing` instead
                      try:
                          f = self.opener(
                              self._indexfile, mode=b"r+", checkambig=self._checkambig
                          )
                          if self._docket is None:
                              f.seek(0, os.SEEK_END)
                          else:
                              f.seek(self._docket.index_end, os.SEEK_SET)
                          return f
                      except FileNotFoundError:
                          return self.opener(
                              self._indexfile, mode=b"w+", checkambig=self._checkambig
                          )
                  def __index_new_fp(self):
                      # You should not use this unless you are upgrading from inline revlog
                      return self.opener(
                          self._indexfile,
                          mode=b"w",
                          checkambig=self._checkambig,
                          atomictemp=True,
                      )
                  def _datafp(self, mode=b'r'):
                      """file object for the revlog's data file"""
                      return self.opener(self._datafile, mode=mode)
                  @contextlib.contextmanager
                  def _sidedatareadfp(self):
                      """file object suitable to read sidedata"""
                      if self._writinghandles:
                          yield self._writinghandles[2]
                      else:
                          with self.opener(self._sidedatafile) as fp:
                              yield fp
                  def tiprev(self):
                      return len(self.index) - 1
                  def tip(self):
                      return self.node(self.tiprev())
                  def __contains__(self, rev):
                      return 0 <= rev < len(self)
                  def __len__(self):
                      return len(self.index)
                  def __iter__(self):
                      return iter(range(len(self)))
                  def revs(self, start=0, stop=None):
                      """iterate over all rev in this revlog (from start to stop)"""
                      return storageutil.iterrevs(len(self), start=start, stop=stop)
                  def hasnode(self, node):
                      try:
                          self.rev(node)
                          return True
                      except KeyError:
                          return False
                  def candelta(self, baserev, rev):
                      """whether two revisions (baserev, rev) can be delta-ed or not"""
                      # Disable delta if either rev requires a content-changing flag
                      # processor (ex. LFS). This is because such flag processor can alter
                      # the rawtext content that the delta will be based on, and two clients
                      # could have a same revlog node with different flags (i.e. different
                      # rawtext contents) and the delta could be incompatible.
                      if (self.flags(baserev) & REVIDX_RAWTEXT_CHANGING_FLAGS) or (
                          self.flags(rev) & REVIDX_RAWTEXT_CHANGING_FLAGS
                      ):
                          return False
                      return True
                  def update_caches(self, transaction):
                      if self._nodemap_file is not None:
                          if transaction is None:
                              nodemaputil.update_persistent_nodemap(self)
                          else:
                              nodemaputil.setup_persistent_nodemap(transaction, self)
                  def clearcaches(self):
                      self._revisioncache = None
                      self._chainbasecache.clear()
                      self._segmentfile.clear_cache()
                      self._segmentfile_sidedata.clear_cache()
                      self._pcache = {}
                      self._nodemap_docket = None
                      self.index.clearcaches()
                      # The python code is the one responsible for validating the docket, we
                      # end up having to refresh it here.
                      use_nodemap = (
                          not self._inline
                          and self._nodemap_file is not None
                          and util.safehasattr(self.index, 'update_nodemap_data')
                      )
                      if use_nodemap:
                          nodemap_data = nodemaputil.persisted_data(self)
                          if nodemap_data is not None:
                              self._nodemap_docket = nodemap_data[0]
                              self.index.update_nodemap_data(*nodemap_data)
                  def rev(self, node):
                      try:
                          return self.index.rev(node)
                      except TypeError:
                          raise
                      except error.RevlogError:
                          # parsers.c radix tree lookup failed
                          if (
                              node == self.nodeconstants.wdirid
                              or node in self.nodeconstants.wdirfilenodeids
                          ):
                              raise error.WdirUnsupported
                          raise error.LookupError(node, self.display_id, _(b'no node'))
                  # Accessors for index entries.
                  # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes
                  # are flags.
                  def start(self, rev):
                      return int(self.index[rev][0] >> 16)
                  def sidedata_cut_off(self, rev):
                      sd_cut_off = self.index[rev][8]
                      if sd_cut_off != 0:
                          return sd_cut_off
                      # This is some annoying dance, because entries without sidedata
                      # currently use 0 as their ofsset. (instead of previous-offset +
                      # previous-size)
                      #
                      # We should reconsider this sidedata → 0 sidata_offset policy.
                      # In the meantime, we need this.
                      while 0 <= rev:
                          e = self.index[rev]
                          if e[9] != 0:
                              return e[8] + e[9]
                          rev -= 1
                      return 0
                  def flags(self, rev):
                      return self.index[rev][0] & 0xFFFF
                  def length(self, rev):
                      return self.index[rev][1]
                  def sidedata_length(self, rev):
                      if not self.hassidedata:
                          return 0
                      return self.index[rev][9]
                  def rawsize(self, rev):
                      """return the length of the uncompressed text for a given revision"""
                      l = self.index[rev][2]
                      if l >= 0:
                          return l
                      t = self.rawdata(rev)
                      return len(t)
                  def size(self, rev):
                      """length of non-raw text (processed by a "read" flag processor)"""
                      # fast path: if no "read" flag processor could change the content,
                      # size is rawsize. note: ELLIPSIS is known to not change the content.
                      flags = self.flags(rev)
                      if flags & (flagutil.REVIDX_KNOWN_FLAGS ^ REVIDX_ELLIPSIS) == 0:
                          return self.rawsize(rev)
                      return len(self.revision(rev))
                  def fast_rank(self, rev):
                      """Return the rank of a revision if already known, or None otherwise.
                      The rank of a revision is the size of the sub-graph it defines as a
                      head. Equivalently, the rank of a revision `r` is the size of the set
                      `ancestors(r)`, `r` included.
                      This method returns the rank retrieved from the revlog in constant
                      time. It makes no attempt at computing unknown values for versions of
                      the revlog which do not persist the rank.
                      """
                      rank = self.index[rev][ENTRY_RANK]
                      if self._format_version != CHANGELOGV2 or rank == RANK_UNKNOWN:
                          return None
                      if rev == nullrev:
                          return 0  # convention
                      return rank
                  def chainbase(self, rev):
                      base = self._chainbasecache.get(rev)
                      if base is not None:
                          return base
                      index = self.index
                      iterrev = rev
                      base = index[iterrev][3]
                      while base != iterrev:
                          iterrev = base
                          base = index[iterrev][3]
                      self._chainbasecache[rev] = base
                      return base
                  def linkrev(self, rev):
                      return self.index[rev][4]
                  def parentrevs(self, rev):
                      try:
                          entry = self.index[rev]
                      except IndexError:
                          if rev == wdirrev:
                              raise error.WdirUnsupported
                          raise
                      if self.canonical_parent_order and entry[5] == nullrev:
                          return entry[6], entry[5]
                      else:
                          return entry[5], entry[6]
                  # fast parentrevs(rev) where rev isn't filtered
                  _uncheckedparentrevs = parentrevs
                  def node(self, rev):
                      try:
                          return self.index[rev][7]
                      except IndexError:
                          if rev == wdirrev:
                              raise error.WdirUnsupported
                          raise
                  # Derived from index values.
                  def end(self, rev):
                      return self.start(rev) + self.length(rev)
                  def parents(self, node):
                      i = self.index
                      d = i[self.rev(node)]
                      # inline node() to avoid function call overhead
                      if self.canonical_parent_order and d[5] == self.nullid:
                          return i[d[6]][7], i[d[5]][7]
                      else:
                          return i[d[5]][7], i[d[6]][7]
                  def chainlen(self, rev):
                      return self._chaininfo(rev)[0]
                  def _chaininfo(self, rev):
                      chaininfocache = self._chaininfocache
                      if rev in chaininfocache:
                          return chaininfocache[rev]
                      index = self.index
                      generaldelta = self._generaldelta
                      iterrev = rev
                      e = index[iterrev]
                      clen = 0
                      compresseddeltalen = 0
                      while iterrev != e[3]:
                          clen += 1
                          compresseddeltalen += e[1]
                          if generaldelta:
                              iterrev = e[3]
                          else:
                              iterrev -= 1
                          if iterrev in chaininfocache:
                              t = chaininfocache[iterrev]
                              clen += t[0]
                              compresseddeltalen += t[1]
                              break
                          e = index[iterrev]
                      else:
                          # Add text length of base since decompressing that also takes
                          # work. For cache hits the length is already included.
                          compresseddeltalen += e[1]
                      r = (clen, compresseddeltalen)
                      chaininfocache[rev] = r
                      return r
                  def _deltachain(self, rev, stoprev=None):
                      """Obtain the delta chain for a revision.
                      ``stoprev`` specifies a revision to stop at. If not specified, we
                      stop at the base of the chain.
                      Returns a 2-tuple of (chain, stopped) where ``chain`` is a list of
                      revs in ascending order and ``stopped`` is a bool indicating whether
                      ``stoprev`` was hit.
                      """
                      # Try C implementation.
                      try:
                          return self.index.deltachain(rev, stoprev, self._generaldelta)
                      except AttributeError:
                          pass
                      chain = []
                      # Alias to prevent attribute lookup in tight loop.
                      index = self.index
                      generaldelta = self._generaldelta
                      iterrev = rev
                      e = index[iterrev]
                      while iterrev != e[3] and iterrev != stoprev:
                          chain.append(iterrev)
                          if generaldelta:
                              iterrev = e[3]
                          else:
                              iterrev -= 1
                          e = index[iterrev]
                      if iterrev == stoprev:
                          stopped = True
                      else:
                          chain.append(iterrev)
                          stopped = False
                      chain.reverse()
                      return chain, stopped
                  def ancestors(self, revs, stoprev=0, inclusive=False):
                      """Generate the ancestors of 'revs' in reverse revision order.
                      Does not generate revs lower than stoprev.
                      See the documentation for ancestor.lazyancestors for more details."""
                      # first, make sure start revisions aren't filtered
                      revs = list(revs)
                      checkrev = self.node
                      for r in revs:
                          checkrev(r)
                      # and we're sure ancestors aren't filtered as well
                      if rustancestor is not None and self.index.rust_ext_compat:
                          lazyancestors = rustancestor.LazyAncestors
                          arg = self.index
                      else:
                          lazyancestors = ancestor.lazyancestors
                          arg = self._uncheckedparentrevs
                      return lazyancestors(arg, revs, stoprev=stoprev, inclusive=inclusive)
                  def descendants(self, revs):
                      return dagop.descendantrevs(revs, self.revs, self.parentrevs)
                  def findcommonmissing(self, common=None, heads=None):
                      """Return a tuple of the ancestors of common and the ancestors of heads
                      that are not ancestors of common. In revset terminology, we return the
                      tuple:
                        ::common, (::heads) - (::common)
                      The list is sorted by revision number, meaning it is
                      topologically sorted.
                      'heads' and 'common' are both lists of node IDs.  If heads is
                      not supplied, uses all of the revlog's heads.  If common is not
                      supplied, uses nullid."""
                      if common is None:
                          common = [self.nullid]
                      if heads is None:
                          heads = self.heads()
                      common = [self.rev(n) for n in common]
                      heads = [self.rev(n) for n in heads]
                      # we want the ancestors, but inclusive
                      class lazyset:
                          def __init__(self, lazyvalues):
                              self.addedvalues = set()
                              self.lazyvalues = lazyvalues
                          def __contains__(self, value):
                              return value in self.addedvalues or value in self.lazyvalues
                          def __iter__(self):
                              added = self.addedvalues
                              for r in added:
                                  yield r
                              for r in self.lazyvalues:
                                  if not r in added:
                                      yield r
                          def add(self, value):
                              self.addedvalues.add(value)
                          def update(self, values):
                              self.addedvalues.update(values)
                      has = lazyset(self.ancestors(common))
                      has.add(nullrev)
                      has.update(common)
                      # take all ancestors from heads that aren't in has
                      missing = set()
                      visit = collections.deque(r for r in heads if r not in has)
                      while visit:
                          r = visit.popleft()
                          if r in missing:
                              continue
                          else:
                              missing.add(r)
                              for p in self.parentrevs(r):
                                  if p not in has:
                                      visit.append(p)
                      missing = list(missing)
                      missing.sort()
                      return has, [self.node(miss) for miss in missing]
                  def incrementalmissingrevs(self, common=None):
                      """Return an object that can be used to incrementally compute the
                      revision numbers of the ancestors of arbitrary sets that are not
                      ancestors of common. This is an ancestor.incrementalmissingancestors
                      object.
                      'common' is a list of revision numbers. If common is not supplied, uses
                      nullrev.
                      """
                      if common is None:
                          common = [nullrev]
                      if rustancestor is not None and self.index.rust_ext_compat:
                          return rustancestor.MissingAncestors(self.index, common)
                      return ancestor.incrementalmissingancestors(self.parentrevs, common)
                  def findmissingrevs(self, common=None, heads=None):
                      """Return the revision numbers of the ancestors of heads that
                      are not ancestors of common.
                      More specifically, return a list of revision numbers corresponding to
                      nodes N such that every N satisfies the following constraints:
 . N is an ancestor of some node in 'heads'
 . N is not an ancestor of any node in 'common'
                      The list is sorted by revision number, meaning it is
                      topologically sorted.
                      'heads' and 'common' are both lists of revision numbers.  If heads is
                      not supplied, uses all of the revlog's heads.  If common is not
                      supplied, uses nullid."""
                      if common is None:
                          common = [nullrev]
                      if heads is None:
                          heads = self.headrevs()
                      inc = self.incrementalmissingrevs(common=common)
                      return inc.missingancestors(heads)
                  def findmissing(self, common=None, heads=None):
                      """Return the ancestors of heads that are not ancestors of common.
                      More specifically, return a list of nodes N such that every N
                      satisfies the following constraints:
 . N is an ancestor of some node in 'heads'
 . N is not an ancestor of any node in 'common'
                      The list is sorted by revision number, meaning it is
                      topologically sorted.
                      'heads' and 'common' are both lists of node IDs.  If heads is
                      not supplied, uses all of the revlog's heads.  If common is not
                      supplied, uses nullid."""
                      if common is None:
                          common = [self.nullid]
                      if heads is None:
                          heads = self.heads()
                      common = [self.rev(n) for n in common]
                      heads = [self.rev(n) for n in heads]
                      inc = self.incrementalmissingrevs(common=common)
                      return [self.node(r) for r in inc.missingancestors(heads)]
                  def nodesbetween(self, roots=None, heads=None):
                      """Return a topological path from 'roots' to 'heads'.
                      Return a tuple (nodes, outroots, outheads) where 'nodes' is a
                      topologically sorted list of all nodes N that satisfy both of
                      these constraints:
 . N is a descendant of some node in 'roots'
 . N is an ancestor of some node in 'heads'
                      Every node is considered to be both a descendant and an ancestor
                      of itself, so every reachable node in 'roots' and 'heads' will be
                      included in 'nodes'.
                      'outroots' is the list of reachable nodes in 'roots', i.e., the
                      subset of 'roots' that is returned in 'nodes'.  Likewise,
                      'outheads' is the subset of 'heads' that is also in 'nodes'.
                      'roots' and 'heads' are both lists of node IDs.  If 'roots' is
                      unspecified, uses nullid as the only root.  If 'heads' is
                      unspecified, uses list of all of the revlog's heads."""
                      nonodes = ([], [], [])
                      if roots is not None:
                          roots = list(roots)
                          if not roots:
                              return nonodes
                          lowestrev = min([self.rev(n) for n in roots])
                      else:
                          roots = [self.nullid]  # Everybody's a descendant of nullid
                          lowestrev = nullrev
                      if (lowestrev == nullrev) and (heads is None):
                          # We want _all_ the nodes!
                          return (
                              [self.node(r) for r in self],
                              [self.nullid],
                              list(self.heads()),
                          )
                      if heads is None:
                          # All nodes are ancestors, so the latest ancestor is the last
                          # node.
                          highestrev = len(self) - 1
                          # Set ancestors to None to signal that every node is an ancestor.
                          ancestors = None
                          # Set heads to an empty dictionary for later discovery of heads
                          heads = {}
                      else:
                          heads = list(heads)
                          if not heads:
                              return nonodes
                          ancestors = set()
                          # Turn heads into a dictionary so we can remove 'fake' heads.
                          # Also, later we will be using it to filter out the heads we can't
                          # find from roots.
                          heads = dict.fromkeys(heads, False)
                          # Start at the top and keep marking parents until we're done.
                          nodestotag = set(heads)
                          # Remember where the top was so we can use it as a limit later.
                          highestrev = max([self.rev(n) for n in nodestotag])
                          while nodestotag:
                              # grab a node to tag
                              n = nodestotag.pop()
                              # Never tag nullid
                              if n == self.nullid:
                                  continue
                              # A node's revision number represents its place in a
                              # topologically sorted list of nodes.
                              r = self.rev(n)
                              if r >= lowestrev:
                                  if n not in ancestors:
                                      # If we are possibly a descendant of one of the roots
                                      # and we haven't already been marked as an ancestor
                                      ancestors.add(n)  # Mark as ancestor
                                      # Add non-nullid parents to list of nodes to tag.
                                      nodestotag.update(
                                          [p for p in self.parents(n) if p != self.nullid]
                                      )
                                  elif n in heads:  # We've seen it before, is it a fake head?
                                      # So it is, real heads should not be the ancestors of
                                      # any other heads.
                                      heads.pop(n)
                          if not ancestors:
                              return nonodes
                          # Now that we have our set of ancestors, we want to remove any
                          # roots that are not ancestors.
                          # If one of the roots was nullid, everything is included anyway.
                          if lowestrev > nullrev:
                              # But, since we weren't, let's recompute the lowest rev to not
                              # include roots that aren't ancestors.
                              # Filter out roots that aren't ancestors of heads
                              roots = [root for root in roots if root in ancestors]
                              # Recompute the lowest revision
                              if roots:
                                  lowestrev = min([self.rev(root) for root in roots])
                              else:
                                  # No more roots?  Return empty list
                                  return nonodes
                          else:
                              # We are descending from nullid, and don't need to care about
                              # any other roots.
                              lowestrev = nullrev
                              roots = [self.nullid]
                      # Transform our roots list into a set.
                      descendants = set(roots)
                      # Also, keep the original roots so we can filter out roots that aren't
                      # 'real' roots (i.e. are descended from other roots).
                      roots = descendants.copy()
                      # Our topologically sorted list of output nodes.
                      orderedout = []
                      # Don't start at nullid since we don't want nullid in our output list,
                      # and if nullid shows up in descendants, empty parents will look like
                      # they're descendants.
                      for r in self.revs(start=max(lowestrev, 0), stop=highestrev + 1):
                          n = self.node(r)
                          isdescendant = False
                          if lowestrev == nullrev:  # Everybody is a descendant of nullid
                              isdescendant = True
                          elif n in descendants:
                              # n is already a descendant
                              isdescendant = True
                              # This check only needs to be done here because all the roots
                              # will start being marked is descendants before the loop.
                              if n in roots:
                                  # If n was a root, check if it's a 'real' root.
                                  p = tuple(self.parents(n))
                                  # If any of its parents are descendants, it's not a root.
                                  if (p[0] in descendants) or (p[1] in descendants):
                                      roots.remove(n)
                          else:
                              p = tuple(self.parents(n))
                              # A node is a descendant if either of its parents are
                              # descendants.  (We seeded the dependents list with the roots
                              # up there, remember?)
                              if (p[0] in descendants) or (p[1] in descendants):
                                  descendants.add(n)
                                  isdescendant = True
                          if isdescendant and ((ancestors is None) or (n in ancestors)):
                              # Only include nodes that are both descendants and ancestors.
                              orderedout.append(n)
                              if (ancestors is not None) and (n in heads):
                                  # We're trying to figure out which heads are reachable
                                  # from roots.
                                  # Mark this head as having been reached
                                  heads[n] = True
                              elif ancestors is None:
                                  # Otherwise, we're trying to discover the heads.
                                  # Assume this is a head because if it isn't, the next step
                                  # will eventually remove it.
                                  heads[n] = True
                                  # But, obviously its parents aren't.
                                  for p in self.parents(n):
                                      heads.pop(p, None)
                      heads = [head for head, flag in heads.items() if flag]
                      roots = list(roots)
                      assert orderedout
                      assert roots
                      assert heads
                      return (orderedout, roots, heads)
                  def headrevs(self, revs=None):
                      if revs is None:
                          try:
                              return self.index.headrevs()
                          except AttributeError:
                              return self._headrevs()
                      if rustdagop is not None and self.index.rust_ext_compat:
                          return rustdagop.headrevs(self.index, revs)
                      return dagop.headrevs(revs, self._uncheckedparentrevs)
                  def computephases(self, roots):
                      return self.index.computephasesmapsets(roots)
                  def _headrevs(self):
                      count = len(self)
                      if not count:
                          return [nullrev]
                      # we won't iter over filtered rev so nobody is a head at start
                      ishead = [0] * (count + 1)
                      index = self.index
                      for r in self:
                          ishead[r] = 1  # I may be an head
                          e = index[r]
                          ishead[e[5]] = ishead[e[6]] = 0  # my parent are not
                      return [r for r, val in enumerate(ishead) if val]
                  def heads(self, start=None, stop=None):
                      """return the list of all nodes that have no children
                      if start is specified, only heads that are descendants of
                      start will be returned
                      if stop is specified, it will consider all the revs from stop
                      as if they had no children
                      """
                      if start is None and stop is None:
                          if not len(self):
                              return [self.nullid]
                          return [self.node(r) for r in self.headrevs()]
                      if start is None:
                          start = nullrev
                      else:
                          start = self.rev(start)
                      stoprevs = {self.rev(n) for n in stop or []}
                      revs = dagop.headrevssubset(
                          self.revs, self.parentrevs, startrev=start, stoprevs=stoprevs
                      )
                      return [self.node(rev) for rev in revs]
                  def children(self, node):
                      """find the children of a given node"""
                      c = []
                      p = self.rev(node)
                      for r in self.revs(start=p + 1):
                          prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
                          if prevs:
                              for pr in prevs:
                                  if pr == p:
                                      c.append(self.node(r))
                          elif p == nullrev:
                              c.append(self.node(r))
                      return c
                  def commonancestorsheads(self, a, b):
                      """calculate all the heads of the common ancestors of nodes a and b"""
                      a, b = self.rev(a), self.rev(b)
                      ancs = self._commonancestorsheads(a, b)
                      return pycompat.maplist(self.node, ancs)
                  def _commonancestorsheads(self, *revs):
                      """calculate all the heads of the common ancestors of revs"""
                      try:
                          ancs = self.index.commonancestorsheads(*revs)
                      except (AttributeError, OverflowError):  # C implementation failed
                          ancs = ancestor.commonancestorsheads(self.parentrevs, *revs)
                      return ancs
                  def isancestor(self, a, b):
                      """return True if node a is an ancestor of node b
                      A revision is considered an ancestor of itself."""
                      a, b = self.rev(a), self.rev(b)
                      return self.isancestorrev(a, b)
                  def isancestorrev(self, a, b):
                      """return True if revision a is an ancestor of revision b
                      A revision is considered an ancestor of itself.
                      The implementation of this is trivial but the use of
                      reachableroots is not."""
                      if a == nullrev:
                          return True
                      elif a == b:
                          return True
                      elif a > b:
                          return False
                      return bool(self.reachableroots(a, [b], [a], includepath=False))
                  def reachableroots(self, minroot, heads, roots, includepath=False):
                      """return (heads(::(<roots> and <roots>::<heads>)))
                      If includepath is True, return (<roots>::<heads>)."""
                      try:
                          return self.index.reachableroots2(
                              minroot, heads, roots, includepath
                          )
                      except AttributeError:
                          return dagop._reachablerootspure(
                              self.parentrevs, minroot, roots, heads, includepath
                          )
                  def ancestor(self, a, b):
                      """calculate the "best" common ancestor of nodes a and b"""
                      a, b = self.rev(a), self.rev(b)
                      try:
                          ancs = self.index.ancestors(a, b)
                      except (AttributeError, OverflowError):
                          ancs = ancestor.ancestors(self.parentrevs, a, b)
                      if ancs:
                          # choose a consistent winner when there's a tie
                          return min(map(self.node, ancs))
                      return self.nullid
                  def _match(self, id):
                      if isinstance(id, int):
                          # rev
                          return self.node(id)
                      if len(id) == self.nodeconstants.nodelen:
                          # possibly a binary node
                          # odds of a binary node being all hex in ASCII are 1 in 10**25
                          try:
                              node = id
                              self.rev(node)  # quick search the index
                              return node
                          except error.LookupError:
                              pass  # may be partial hex id
                      try:
                          # str(rev)
                          rev = int(id)
                          if b"%d" % rev != id:
                              raise ValueError
                          if rev < 0:
                              rev = len(self) + rev
                          if rev < 0 or rev >= len(self):
                              raise ValueError
                          return self.node(rev)
                      except (ValueError, OverflowError):
                          pass
                      if len(id) == 2 * self.nodeconstants.nodelen:
                          try:
                              # a full hex nodeid?
                              node = bin(id)
                              self.rev(node)
                              return node
                          except (binascii.Error, error.LookupError):
                              pass
                  def _partialmatch(self, id):
                      # we don't care wdirfilenodeids as they should be always full hash
                      maybewdir = self.nodeconstants.wdirhex.startswith(id)
                      ambiguous = False
                      try:
                          partial = self.index.partialmatch(id)
                          if partial and self.hasnode(partial):
                              if maybewdir:
                                  # single 'ff...' match in radix tree, ambiguous with wdir
                                  ambiguous = True
                              else:
                                  return partial
                          elif maybewdir:
                              # no 'ff...' match in radix tree, wdir identified
                              raise error.WdirUnsupported
                          else:
                              return None
                      except error.RevlogError:
                          # parsers.c radix tree lookup gave multiple matches
                          # fast path: for unfiltered changelog, radix tree is accurate
                          if not getattr(self, 'filteredrevs', None):
                              ambiguous = True
                          # fall through to slow path that filters hidden revisions
                      except (AttributeError, ValueError):
                          # we are pure python, or key is not hex
                          pass
                      if ambiguous:
                          raise error.AmbiguousPrefixLookupError(
                              id, self.display_id, _(b'ambiguous identifier')
                          )
                      if id in self._pcache:
                          return self._pcache[id]
                      if len(id) <= 40:
                          # hex(node)[:...]
                          l = len(id) // 2 * 2  # grab an even number of digits
                          try:
                              # we're dropping the last digit, so let's check that it's hex,
                              # to avoid the expensive computation below if it's not
                              if len(id) % 2 > 0:
                                  if not (id[-1] in hexdigits):
                                      return None
                              prefix = bin(id[:l])
                          except binascii.Error:
                              pass
                          else:
                              nl = [e[7] for e in self.index if e[7].startswith(prefix)]
                              nl = [
                                  n for n in nl if hex(n).startswith(id) and self.hasnode(n)
                              ]
                              if self.nodeconstants.nullhex.startswith(id):
                                  nl.append(self.nullid)
                              if len(nl) > 0:
                                  if len(nl) == 1 and not maybewdir:
                                      self._pcache[id] = nl[0]
                                      return nl[0]
                                  raise error.AmbiguousPrefixLookupError(
                                      id, self.display_id, _(b'ambiguous identifier')
                                  )
                              if maybewdir:
                                  raise error.WdirUnsupported
                              return None
                  def lookup(self, id):
                      """locate a node based on:
                      - revision number or str(revision number)
                      - nodeid or subset of hex nodeid
                      """
                      n = self._match(id)
                      if n is not None:
                          return n
                      n = self._partialmatch(id)
                      if n:
                          return n
                      raise error.LookupError(id, self.display_id, _(b'no match found'))
                  def shortest(self, node, minlength=1):
                      """Find the shortest unambiguous prefix that matches node."""
                      def isvalid(prefix):
                          try:
                              matchednode = self._partialmatch(prefix)
                          except error.AmbiguousPrefixLookupError:
                              return False
                          except error.WdirUnsupported:
                              # single 'ff...' match
                              return True
                          if matchednode is None:
                              raise error.LookupError(node, self.display_id, _(b'no node'))
                          return True
                      def maybewdir(prefix):
                          return all(c == b'f' for c in pycompat.iterbytestr(prefix))
                      hexnode = hex(node)
                      def disambiguate(hexnode, minlength):
                          """Disambiguate against wdirid."""
                          for length in range(minlength, len(hexnode) + 1):
                              prefix = hexnode[:length]
                              if not maybewdir(prefix):
                                  return prefix
                      if not getattr(self, 'filteredrevs', None):
                          try:
                              length = max(self.index.shortest(node), minlength)
                              return disambiguate(hexnode, length)
                          except error.RevlogError:
                              if node != self.nodeconstants.wdirid:
                                  raise error.LookupError(
                                      node, self.display_id, _(b'no node')
                                  )
                          except AttributeError:
                              # Fall through to pure code
                              pass
                      if node == self.nodeconstants.wdirid:
                          for length in range(minlength, len(hexnode) + 1):
                              prefix = hexnode[:length]
                              if isvalid(prefix):
                                  return prefix
                      for length in range(minlength, len(hexnode) + 1):
                          prefix = hexnode[:length]
                          if isvalid(prefix):
                              return disambiguate(hexnode, length)
                  def cmp(self, node, text):
                      """compare text with a given file revision
                      returns True if text is different than what is stored.
                      """
                      p1, p2 = self.parents(node)
                      return storageutil.hashrevisionsha1(text, p1, p2) != node
                  def _getsegmentforrevs(self, startrev, endrev, df=None):
                      """Obtain a segment of raw data corresponding to a range of revisions.
                      Accepts the start and end revisions and an optional already-open
                      file handle to be used for reading. If the file handle is read, its
                      seek position will not be preserved.
                      Requests for data may be satisfied by a cache.
                      Returns a 2-tuple of (offset, data) for the requested range of
                      revisions. Offset is the integer offset from the beginning of the
                      revlog and data is a str or buffer of the raw byte data.
                      Callers will need to call ``self.start(rev)`` and ``self.length(rev)``
                      to determine where each revision's data begins and ends.
                      """
                      # Inlined self.start(startrev) & self.end(endrev) for perf reasons
                      # (functions are expensive).
                      index = self.index
                      istart = index[startrev]
                      start = int(istart[0] >> 16)
                      if startrev == endrev:
                          end = start + istart[1]
                      else:
                          iend = index[endrev]
                          end = int(iend[0] >> 16) + iend[1]
                      if self._inline:
                          start += (startrev + 1) * self.index.entry_size
                          end += (endrev + 1) * self.index.entry_size
                      length = end - start
                      return start, self._segmentfile.read_chunk(start, length, df)
                  def _chunk(self, rev, df=None):
                      """Obtain a single decompressed chunk for a revision.
                      Accepts an integer revision and an optional already-open file handle
                      to be used for reading. If used, the seek position of the file will not
                      be preserved.
                      Returns a str holding uncompressed data for the requested revision.
                      """
                      compression_mode = self.index[rev][10]
                      data = self._getsegmentforrevs(rev, rev, df=df)[1]
                      if compression_mode == COMP_MODE_PLAIN:
                          return data
                      elif compression_mode == COMP_MODE_DEFAULT:
                          return self._decompressor(data)
                      elif compression_mode == COMP_MODE_INLINE:
                          return self.decompress(data)
                      else:
                          msg = b'unknown compression mode %d'
                          msg %= compression_mode
                          raise error.RevlogError(msg)
                  def _chunks(self, revs, df=None, targetsize=None):
                      """Obtain decompressed chunks for the specified revisions.
                      Accepts an iterable of numeric revisions that are assumed to be in
                      ascending order. Also accepts an optional already-open file handle
                      to be used for reading. If used, the seek position of the file will
                      not be preserved.
                      This function is similar to calling ``self._chunk()`` multiple times,
                      but is faster.
                      Returns a list with decompressed data for each requested revision.
                      """
                      if not revs:
                          return []
                      start = self.start
                      length = self.length
                      inline = self._inline
                      iosize = self.index.entry_size
                      buffer = util.buffer
                      l = []
                      ladd = l.append
                      if not self._withsparseread:
                          slicedchunks = (revs,)
                      else:
                          slicedchunks = deltautil.slicechunk(
                              self, revs, targetsize=targetsize
                          )
                      for revschunk in slicedchunks:
                          firstrev = revschunk[0]
                          # Skip trailing revisions with empty diff
                          for lastrev in revschunk[::-1]:
                              if length(lastrev) != 0:
                                  break
                          try:
                              offset, data = self._getsegmentforrevs(firstrev, lastrev, df=df)
                          except OverflowError:
                              # issue4215 - we can't cache a run of chunks greater than
                              # 2G on Windows
                              return [self._chunk(rev, df=df) for rev in revschunk]
                          decomp = self.decompress
                          # self._decompressor might be None, but will not be used in that case
                          def_decomp = self._decompressor
                          for rev in revschunk:
                              chunkstart = start(rev)
                              if inline:
                                  chunkstart += (rev + 1) * iosize
                              chunklength = length(rev)
                              comp_mode = self.index[rev][10]
                              c = buffer(data, chunkstart - offset, chunklength)
                              if comp_mode == COMP_MODE_PLAIN:
                                  ladd(c)
                              elif comp_mode == COMP_MODE_INLINE:
                                  ladd(decomp(c))
                              elif comp_mode == COMP_MODE_DEFAULT:
                                  ladd(def_decomp(c))
                              else:
                                  msg = b'unknown compression mode %d'
                                  msg %= comp_mode
                                  raise error.RevlogError(msg)
                      return l
                  def deltaparent(self, rev):
                      """return deltaparent of the given revision"""
                      base = self.index[rev][3]
                      if base == rev:
                          return nullrev
                      elif self._generaldelta:
                          return base
                      else:
                          return rev - 1
                  def issnapshot(self, rev):
                      """tells whether rev is a snapshot"""
                      if not self._sparserevlog:
                          return self.deltaparent(rev) == nullrev
                      elif util.safehasattr(self.index, 'issnapshot'):
                          # directly assign the method to cache the testing and access
                          self.issnapshot = self.index.issnapshot
                          return self.issnapshot(rev)
                      if rev == nullrev:
                          return True
                      entry = self.index[rev]
                      base = entry[3]
                      if base == rev:
                          return True
                      if base == nullrev:
                          return True
                      p1 = entry[5]
                      while self.length(p1) == 0:
                          b = self.deltaparent(p1)
                          if b == p1:
                              break
                          p1 = b
                      p2 = entry[6]
                      while self.length(p2) == 0:
                          b = self.deltaparent(p2)
                          if b == p2:
                              break
                          p2 = b
                      if base == p1 or base == p2:
                          return False
                      return self.issnapshot(base)
                  def snapshotdepth(self, rev):
                      """number of snapshot in the chain before this one"""
                      if not self.issnapshot(rev):
                          raise error.ProgrammingError(b'revision %d not a snapshot')
                      return len(self._deltachain(rev)[0]) - 1
                  def revdiff(self, rev1, rev2):
                      """return or calculate a delta between two revisions
                      The delta calculated is in binary form and is intended to be written to
                      revlog data directly. So this function needs raw revision data.
                      """
                      if rev1 != nullrev and self.deltaparent(rev2) == rev1:
                          return bytes(self._chunk(rev2))
                      return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2))
                  def revision(self, nodeorrev, _df=None):
                      """return an uncompressed revision of a given node or revision
                      number.
                      _df - an existing file handle to read from. (internal-only)
                      """
                      return self._revisiondata(nodeorrev, _df)
                  def sidedata(self, nodeorrev, _df=None):
                      """a map of extra data related to the changeset but not part of the hash
                      This function currently return a dictionary. However, more advanced
                      mapping object will likely be used in the future for a more
                      efficient/lazy code.
                      """
                      # deal with <nodeorrev> argument type
                      if isinstance(nodeorrev, int):
                          rev = nodeorrev
                      else:
                          rev = self.rev(nodeorrev)
                      return self._sidedata(rev)
                  def _revisiondata(self, nodeorrev, _df=None, raw=False):
                      # deal with <nodeorrev> argument type
                      if isinstance(nodeorrev, int):
                          rev = nodeorrev
                          node = self.node(rev)
                      else:
                          node = nodeorrev
                          rev = None
                      # fast path the special `nullid` rev
                      if node == self.nullid:
                          return b""
                      # ``rawtext`` is the text as stored inside the revlog. Might be the
                      # revision or might need to be processed to retrieve the revision.
                      rev, rawtext, validated = self._rawtext(node, rev, _df=_df)
                      if raw and validated:
                          # if we don't want to process the raw text and that raw
                          # text is cached, we can exit early.
                          return rawtext
                      if rev is None:
                          rev = self.rev(node)
                      # the revlog's flag for this revision
                      # (usually alter its state or content)
                      flags = self.flags(rev)
                      if validated and flags == REVIDX_DEFAULT_FLAGS:
                          # no extra flags set, no flag processor runs, text = rawtext
                          return rawtext
                      if raw:
                          validatehash = flagutil.processflagsraw(self, rawtext, flags)
                          text = rawtext
                      else:
                          r = flagutil.processflagsread(self, rawtext, flags)
                          text, validatehash = r
                      if validatehash:
                          self.checkhash(text, node, rev=rev)
                      if not validated:
                          self._revisioncache = (node, rev, rawtext)
                      return text
                  def _rawtext(self, node, rev, _df=None):
                      """return the possibly unvalidated rawtext for a revision
                      returns (rev, rawtext, validated)
                      """
                      # revision in the cache (could be useful to apply delta)
                      cachedrev = None
                      # An intermediate text to apply deltas to
                      basetext = None
                      # Check if we have the entry in cache
                      # The cache entry looks like (node, rev, rawtext)
                      if self._revisioncache:
                          if self._revisioncache[0] == node:
                              return (rev, self._revisioncache[2], True)
                          cachedrev = self._revisioncache[1]
                      if rev is None:
                          rev = self.rev(node)
                      chain, stopped = self._deltachain(rev, stoprev=cachedrev)
                      if stopped:
                          basetext = self._revisioncache[2]
                      # drop cache to save memory, the caller is expected to
                      # update self._revisioncache after validating the text
                      self._revisioncache = None
                      targetsize = None
                      rawsize = self.index[rev][2]
                      if 0 <= rawsize:
                          targetsize = 4 * rawsize
                      bins = self._chunks(chain, df=_df, targetsize=targetsize)
                      if basetext is None:
                          basetext = bytes(bins[0])
                          bins = bins[1:]
                      rawtext = mdiff.patches(basetext, bins)
                      del basetext  # let us have a chance to free memory early
                      return (rev, rawtext, False)
                  def _sidedata(self, rev):
                      """Return the sidedata for a given revision number."""
                      index_entry = self.index[rev]
                      sidedata_offset = index_entry[8]
                      sidedata_size = index_entry[9]
                      if self._inline:
                          sidedata_offset += self.index.entry_size * (1 + rev)
                      if sidedata_size == 0:
                          return {}
                      if self._docket.sidedata_end < sidedata_offset + sidedata_size:
                          filename = self._sidedatafile
                          end = self._docket.sidedata_end
                          offset = sidedata_offset
                          length = sidedata_size
                          m = FILE_TOO_SHORT_MSG % (filename, length, offset, end)
                          raise error.RevlogError(m)
                      comp_segment = self._segmentfile_sidedata.read_chunk(
                          sidedata_offset, sidedata_size
                      )
                      comp = self.index[rev][11]
                      if comp == COMP_MODE_PLAIN:
                          segment = comp_segment
                      elif comp == COMP_MODE_DEFAULT:
                          segment = self._decompressor(comp_segment)
                      elif comp == COMP_MODE_INLINE:
                          segment = self.decompress(comp_segment)
                      else:
                          msg = b'unknown compression mode %d'
                          msg %= comp
                          raise error.RevlogError(msg)
                      sidedata = sidedatautil.deserialize_sidedata(segment)
                      return sidedata
                  def rawdata(self, nodeorrev, _df=None):
                      """return an uncompressed raw data of a given node or revision number.
                      _df - an existing file handle to read from. (internal-only)
                      """
                      return self._revisiondata(nodeorrev, _df, raw=True)
                  def hash(self, text, p1, p2):
                      """Compute a node hash.
                      Available as a function so that subclasses can replace the hash
                      as needed.
                      """
                      return storageutil.hashrevisionsha1(text, p1, p2)
                  def checkhash(self, text, node, p1=None, p2=None, rev=None):
                      """Check node hash integrity.
                      Available as a function so that subclasses can extend hash mismatch
                      behaviors as needed.
                      """
                      try:
                          if p1 is None and p2 is None:
                              p1, p2 = self.parents(node)
                          if node != self.hash(text, p1, p2):
                              # Clear the revision cache on hash failure. The revision cache
                              # only stores the raw revision and clearing the cache does have
                              # the side-effect that we won't have a cache hit when the raw
                              # revision data is accessed. But this case should be rare and
                              # it is extra work to teach the cache about the hash
                              # verification state.
                              if self._revisioncache and self._revisioncache[0] == node:
                                  self._revisioncache = None
                              revornode = rev
                              if revornode is None:
                                  revornode = templatefilters.short(hex(node))
                              raise error.RevlogError(
                                  _(b"integrity check failed on %s:%s")
                                  % (self.display_id, pycompat.bytestr(revornode))
                              )
                      except error.RevlogError:
                          if self._censorable and storageutil.iscensoredtext(text):
                              raise error.CensoredNodeError(self.display_id, node, text)
                          raise
                  @property
                  def _split_index_file(self):
                      """the path where to expect the index of an ongoing splitting operation
                      The file will only exist if a splitting operation is in progress, but
                      it is always expected at the same location."""
-                     parts = os.path.split(self.radix)
+                     parts = self.radix.split(b'/')
                      if len(parts) > 1:
                          # adds a '-s' prefix to the ``data/` or `meta/` base
                          head = parts[0] + b'-s'
-                         return os.path.join(head, *parts[1:])
+                         mids = parts[1:-1]
+                         tail = parts[-1] + b'.i'
+                         pieces = [head] + mids + [tail]
+                         return b'/'.join(pieces)
                      else:
                          # the revlog is stored at the root of the store (changelog or
                          # manifest), no risk of collision.
                          return self.radix + b'.i.s'
                  def _enforceinlinesize(self, tr, side_write=True):
                      """Check if the revlog is too big for inline and convert if so.
                      This should be called after revisions are added to the revlog. If the
                      revlog has grown too large to be an inline revlog, it will convert it
                      to use multiple index and data files.
                      """
                      tiprev = len(self) - 1
                      total_size = self.start(tiprev) + self.length(tiprev)
                      if not self._inline or total_size < _maxinline:
                          return
                      troffset = tr.findoffset(self._indexfile)
                      if troffset is None:
                          raise error.RevlogError(
                              _(b"%s not found in the transaction") % self._indexfile
                          )
                      if troffset:
                          tr.addbackup(self._indexfile, for_offset=True)
                      tr.add(self._datafile, 0)
                      existing_handles = False
                      if self._writinghandles is not None:
                          existing_handles = True
                          fp = self._writinghandles[0]
                          fp.flush()
                          fp.close()
                          # We can't use the cached file handle after close(). So prevent
                          # its usage.
                          self._writinghandles = None
                          self._segmentfile.writing_handle = None
                          # No need to deal with sidedata writing handle as it is only
                          # relevant with revlog-v2 which is never inline, not reaching
                          # this code
                      if side_write:
                          old_index_file_path = self._indexfile
                          new_index_file_path = self._split_index_file
                          opener = self.opener
                          weak_self = weakref.ref(self)
                          # the "split" index replace the real index when the transaction is finalized
                          def finalize_callback(tr):
                              opener.rename(
                                  new_index_file_path,
                                  old_index_file_path,
                                  checkambig=True,
                              )
                              maybe_self = weak_self()
                              if maybe_self is not None:
                                  maybe_self._indexfile = old_index_file_path
                          def abort_callback(tr):
                              maybe_self = weak_self()
                              if maybe_self is not None:
                                  maybe_self._indexfile = old_index_file_path
                          tr.registertmp(new_index_file_path)
                          if self.target[1] is not None:
                              callback_id = b'000-revlog-split-%d-%s' % self.target
                          else:
                              callback_id = b'000-revlog-split-%d' % self.target[0]
                          tr.addfinalize(callback_id, finalize_callback)
                          tr.addabort(callback_id, abort_callback)
                      new_dfh = self._datafp(b'w+')
                      new_dfh.truncate(0)  # drop any potentially existing data
                      try:
                          with self._indexfp() as read_ifh:
                              for r in self:
                                  new_dfh.write(self._getsegmentforrevs(r, r, df=read_ifh)[1])
                              new_dfh.flush()
                          if side_write:
                              self._indexfile = new_index_file_path
                          with self.__index_new_fp() as fp:
                              self._format_flags &= ~FLAG_INLINE_DATA
                              self._inline = False
                              for i in self:
                                  e = self.index.entry_binary(i)
                                  if i == 0 and self._docket is None:
                                      header = self._format_flags | self._format_version
                                      header = self.index.pack_header(header)
                                      e = header + e
                                  fp.write(e)
                              if self._docket is not None:
                                  self._docket.index_end = fp.tell()
                              # If we don't use side-write, the temp file replace the real
                              # index when we exit the context manager
                          nodemaputil.setup_persistent_nodemap(tr, self)
                          self._segmentfile = randomaccessfile.randomaccessfile(
                              self.opener,
                              self._datafile,
                              self._chunkcachesize,
                          )
                          if existing_handles:
                              # switched from inline to conventional reopen the index
                              ifh = self.__index_write_fp()
                              self._writinghandles = (ifh, new_dfh, None)
                              self._segmentfile.writing_handle = new_dfh
                              new_dfh = None
                              # No need to deal with sidedata writing handle as it is only
                              # relevant with revlog-v2 which is never inline, not reaching
                              # this code
                      finally:
                          if new_dfh is not None:
                              new_dfh.close()
                  def _nodeduplicatecallback(self, transaction, node):
                      """called when trying to add a node already stored."""
                  @contextlib.contextmanager
                  def reading(self):
                      """Context manager that keeps data and sidedata files open for reading"""
                      with self._segmentfile.reading():
                          with self._segmentfile_sidedata.reading():
                              yield
                  @contextlib.contextmanager
                  def _writing(self, transaction):
                      if self._trypending:
                          msg = b'try to write in a `trypending` revlog: %s'
                          msg %= self.display_id
                          raise error.ProgrammingError(msg)
                      if self._writinghandles is not None:
                          yield
                      else:
                          ifh = dfh = sdfh = None
                          try:
                              r = len(self)
                              # opening the data file.
                              dsize = 0
                              if r:
                                  dsize = self.end(r - 1)
                              dfh = None
                              if not self._inline:
                                  try:
                                      dfh = self._datafp(b"r+")
                                      if self._docket is None:
                                          dfh.seek(0, os.SEEK_END)
                                      else:
                                          dfh.seek(self._docket.data_end, os.SEEK_SET)
                                  except FileNotFoundError:
                                      dfh = self._datafp(b"w+")
                                  transaction.add(self._datafile, dsize)
                              if self._sidedatafile is not None:
                                  # revlog-v2 does not inline, help Pytype
                                  assert dfh is not None
                                  try:
                                      sdfh = self.opener(self._sidedatafile, mode=b"r+")
                                      dfh.seek(self._docket.sidedata_end, os.SEEK_SET)
                                  except FileNotFoundError:
                                      sdfh = self.opener(self._sidedatafile, mode=b"w+")
                                  transaction.add(
                                      self._sidedatafile, self._docket.sidedata_end
                                  )
                              # opening the index file.
                              isize = r * self.index.entry_size
                              ifh = self.__index_write_fp()
                              if self._inline:
                                  transaction.add(self._indexfile, dsize + isize)
                              else:
                                  transaction.add(self._indexfile, isize)
                              # exposing all file handle for writing.
                              self._writinghandles = (ifh, dfh, sdfh)
                              self._segmentfile.writing_handle = ifh if self._inline else dfh
                              self._segmentfile_sidedata.writing_handle = sdfh
                              yield
                              if self._docket is not None:
                                  self._write_docket(transaction)
                          finally:
                              self._writinghandles = None
                              self._segmentfile.writing_handle = None
                              self._segmentfile_sidedata.writing_handle = None
                              if dfh is not None:
                                  dfh.close()
                              if sdfh is not None:
                                  sdfh.close()
                              # closing the index file last to avoid exposing referent to
                              # potential unflushed data content.
                              if ifh is not None:
                                  ifh.close()
                  def _write_docket(self, transaction):
                      """write the current docket on disk
                      Exist as a method to help changelog to implement transaction logic
                      We could also imagine using the same transaction logic for all revlog
                      since docket are cheap."""
                      self._docket.write(transaction)
                  def addrevision(
                      self,
                      text,
                      transaction,
                      link,
                      p1,
                      p2,
                      cachedelta=None,
                      node=None,
                      flags=REVIDX_DEFAULT_FLAGS,
                      deltacomputer=None,
                      sidedata=None,
                  ):
                      """add a revision to the log
                      text - the revision data to add
                      transaction - the transaction object used for rollback
                      link - the linkrev data to add
                      p1, p2 - the parent nodeids of the revision
                      cachedelta - an optional precomputed delta
                      node - nodeid of revision; typically node is not specified, and it is
                          computed by default as hash(text, p1, p2), however subclasses might
                          use different hashing method (and override checkhash() in such case)
                      flags - the known flags to set on the revision
                      deltacomputer - an optional deltacomputer instance shared between
                          multiple calls
                      """
                      if link == nullrev:
                          raise error.RevlogError(
                              _(b"attempted to add linkrev -1 to %s") % self.display_id
                          )
                      if sidedata is None:
                          sidedata = {}
                      elif sidedata and not self.hassidedata:
                          raise error.ProgrammingError(
                              _(b"trying to add sidedata to a revlog who don't support them")
                          )
                      if flags:
                          node = node or self.hash(text, p1, p2)
                      rawtext, validatehash = flagutil.processflagswrite(self, text, flags)
                      # If the flag processor modifies the revision data, ignore any provided
                      # cachedelta.
                      if rawtext != text:
                          cachedelta = None
                      if len(rawtext) > _maxentrysize:
                          raise error.RevlogError(
                              _(
                                  b"%s: size of %d bytes exceeds maximum revlog storage of 2GiB"
                              )
                              % (self.display_id, len(rawtext))
                          )
                      node = node or self.hash(rawtext, p1, p2)
                      rev = self.index.get_rev(node)
                      if rev is not None:
                          return rev
                      if validatehash:
                          self.checkhash(rawtext, node, p1=p1, p2=p2)
                      return self.addrawrevision(
                          rawtext,
                          transaction,
                          link,
                          p1,
                          p2,
                          node,
                          flags,
                          cachedelta=cachedelta,
                          deltacomputer=deltacomputer,
                          sidedata=sidedata,
                      )
                  def addrawrevision(
                      self,
                      rawtext,
                      transaction,
                      link,
                      p1,
                      p2,
                      node,
                      flags,
                      cachedelta=None,
                      deltacomputer=None,
                      sidedata=None,
                  ):
                      """add a raw revision with known flags, node and parents
                      useful when reusing a revision not stored in this revlog (ex: received
                      over wire, or read from an external bundle).
                      """
                      with self._writing(transaction):
                          return self._addrevision(
                              node,
                              rawtext,
                              transaction,
                              link,
                              p1,
                              p2,
                              flags,
                              cachedelta,
                              deltacomputer=deltacomputer,
                              sidedata=sidedata,
                          )
                  def compress(self, data):
                      """Generate a possibly-compressed representation of data."""
                      if not data:
                          return b'', data
                      compressed = self._compressor.compress(data)
                      if compressed:
                          # The revlog compressor added the header in the returned data.
                          return b'', compressed
                      if data[0:1] == b'\0':
                          return b'', data
                      return b'u', data
                  def decompress(self, data):
                      """Decompress a revlog chunk.
                      The chunk is expected to begin with a header identifying the
                      format type so it can be routed to an appropriate decompressor.
                      """
                      if not data:
                          return data
                      # Revlogs are read much more frequently than they are written and many
                      # chunks only take microseconds to decompress, so performance is
                      # important here.
                      #
                      # We can make a few assumptions about revlogs:
                      #
                      # 1) the majority of chunks will be compressed (as opposed to inline
                      #    raw data).
                      # 2) decompressing *any* data will likely by at least 10x slower than
                      #    returning raw inline data.
                      # 3) we want to prioritize common and officially supported compression
                      #    engines
                      #
                      # It follows that we want to optimize for "decompress compressed data
                      # when encoded with common and officially supported compression engines"
                      # case over "raw data" and "data encoded by less common or non-official
                      # compression engines." That is why we have the inline lookup first
                      # followed by the compengines lookup.
                      #
                      # According to `hg perfrevlogchunks`, this is ~0.5% faster for zlib
                      # compressed chunks. And this matters for changelog and manifest reads.
                      t = data[0:1]
                      if t == b'x':
                          try:
                              return _zlibdecompress(data)
                          except zlib.error as e:
                              raise error.RevlogError(
                                  _(b'revlog decompress error: %s')
                                  % stringutil.forcebytestr(e)
                              )
                      # '\0' is more common than 'u' so it goes first.
                      elif t == b'\0':
                          return data
                      elif t == b'u':
                          return util.buffer(data, 1)
                      compressor = self._get_decompressor(t)
                      return compressor.decompress(data)
                  def _addrevision(
                      self,
                      node,
                      rawtext,
                      transaction,
                      link,
                      p1,
                      p2,
                      flags,
                      cachedelta,
                      alwayscache=False,
                      deltacomputer=None,
                      sidedata=None,
                  ):
                      """internal function to add revisions to the log
                      see addrevision for argument descriptions.
                      note: "addrevision" takes non-raw text, "_addrevision" takes raw text.
                      if "deltacomputer" is not provided or None, a defaultdeltacomputer will
                      be used.
                      invariants:
                      - rawtext is optional (can be None); if not set, cachedelta must be set.
                        if both are set, they must correspond to each other.
                      """
                      if node == self.nullid:
                          raise error.RevlogError(
                              _(b"%s: attempt to add null revision") % self.display_id
                          )
                      if (
                          node == self.nodeconstants.wdirid
                          or node in self.nodeconstants.wdirfilenodeids
                      ):
                          raise error.RevlogError(
                              _(b"%s: attempt to add wdir revision") % self.display_id
                          )
                      if self._writinghandles is None:
                          msg = b'adding revision outside `revlog._writing` context'
                          raise error.ProgrammingError(msg)
                      if self._inline:
                          fh = self._writinghandles[0]
                      else:
                          fh = self._writinghandles[1]
                      btext = [rawtext]
                      curr = len(self)
                      prev = curr - 1
                      offset = self._get_data_offset(prev)
                      if self._concurrencychecker:
                          ifh, dfh, sdfh = self._writinghandles
                          # XXX no checking for the sidedata file
                          if self._inline:
                              # offset is "as if" it were in the .d file, so we need to add on
                              # the size of the entry metadata.
                              self._concurrencychecker(
                                  ifh, self._indexfile, offset + curr * self.index.entry_size
                              )
                          else:
                              # Entries in the .i are a consistent size.
                              self._concurrencychecker(
                                  ifh, self._indexfile, curr * self.index.entry_size
                              )
                              self._concurrencychecker(dfh, self._datafile, offset)
                      p1r, p2r = self.rev(p1), self.rev(p2)
                      # full versions are inserted when the needed deltas
                      # become comparable to the uncompressed text
                      if rawtext is None:
                          # need rawtext size, before changed by flag processors, which is
                          # the non-raw size. use revlog explicitly to avoid filelog's extra
                          # logic that might remove metadata size.
                          textlen = mdiff.patchedsize(
                              revlog.size(self, cachedelta[0]), cachedelta[1]
                          )
                      else:
                          textlen = len(rawtext)
                      if deltacomputer is None:
                          write_debug = None
                          if self._debug_delta:
                              write_debug = transaction._report
                          deltacomputer = deltautil.deltacomputer(
                              self, write_debug=write_debug
                          )
                      if cachedelta is not None and len(cachedelta) == 2:
                          # If the cached delta has no information about how it should be
                          # reused, add the default reuse instruction according to the
                          # revlog's configuration.
                          if self._generaldelta and self._lazydeltabase:
                              delta_base_reuse = DELTA_BASE_REUSE_TRY
                          else:
                              delta_base_reuse = DELTA_BASE_REUSE_NO
                          cachedelta = (cachedelta[0], cachedelta[1], delta_base_reuse)
                      revinfo = revlogutils.revisioninfo(
                          node,
                          p1,
                          p2,
                          btext,
                          textlen,
                          cachedelta,
                          flags,
                      )
                      deltainfo = deltacomputer.finddeltainfo(revinfo, fh)
                      compression_mode = COMP_MODE_INLINE
                      if self._docket is not None:
                          default_comp = self._docket.default_compression_header
                          r = deltautil.delta_compression(default_comp, deltainfo)
                          compression_mode, deltainfo = r
                      sidedata_compression_mode = COMP_MODE_INLINE
                      if sidedata and self.hassidedata:
                          sidedata_compression_mode = COMP_MODE_PLAIN
                          serialized_sidedata = sidedatautil.serialize_sidedata(sidedata)
                          sidedata_offset = self._docket.sidedata_end
                          h, comp_sidedata = self.compress(serialized_sidedata)
                          if (
                              h != b'u'
                              and comp_sidedata[0:1] != b'\0'
                              and len(comp_sidedata) < len(serialized_sidedata)
                          ):
                              assert not h
                              if (
                                  comp_sidedata[0:1]
                                  == self._docket.default_compression_header
                              ):
                                  sidedata_compression_mode = COMP_MODE_DEFAULT
                                  serialized_sidedata = comp_sidedata
                              else:
                                  sidedata_compression_mode = COMP_MODE_INLINE
                                  serialized_sidedata = comp_sidedata
                      else:
                          serialized_sidedata = b""
                          # Don't store the offset if the sidedata is empty, that way
                          # we can easily detect empty sidedata and they will be no different
                          # than ones we manually add.
                          sidedata_offset = 0
                      rank = RANK_UNKNOWN
                      if self._compute_rank:
                          if (p1r, p2r) == (nullrev, nullrev):
                              rank = 1
                          elif p1r != nullrev and p2r == nullrev:
                              rank = 1 + self.fast_rank(p1r)
                          elif p1r == nullrev and p2r != nullrev:
                              rank = 1 + self.fast_rank(p2r)
                          else:  # merge node
                              if rustdagop is not None and self.index.rust_ext_compat:
                                  rank = rustdagop.rank(self.index, p1r, p2r)
                              else:
                                  pmin, pmax = sorted((p1r, p2r))
                                  rank = 1 + self.fast_rank(pmax)
                                  rank += sum(1 for _ in self.findmissingrevs([pmax], [pmin]))
                      e = revlogutils.entry(
                          flags=flags,
                          data_offset=offset,
                          data_compressed_length=deltainfo.deltalen,
                          data_uncompressed_length=textlen,
                          data_compression_mode=compression_mode,
                          data_delta_base=deltainfo.base,
                          link_rev=link,
                          parent_rev_1=p1r,
                          parent_rev_2=p2r,
                          node_id=node,
                          sidedata_offset=sidedata_offset,
                          sidedata_compressed_length=len(serialized_sidedata),
                          sidedata_compression_mode=sidedata_compression_mode,
                          rank=rank,
                      )
                      self.index.append(e)
                      entry = self.index.entry_binary(curr)
                      if curr == 0 and self._docket is None:
                          header = self._format_flags | self._format_version
                          header = self.index.pack_header(header)
                          entry = header + entry
                      self._writeentry(
                          transaction,
                          entry,
                          deltainfo.data,
                          link,
                          offset,
                          serialized_sidedata,
                          sidedata_offset,
                      )
                      rawtext = btext[0]
                      if alwayscache and rawtext is None:
                          rawtext = deltacomputer.buildtext(revinfo, fh)
                      if type(rawtext) == bytes:  # only accept immutable objects
                          self._revisioncache = (node, curr, rawtext)
                      self._chainbasecache[curr] = deltainfo.chainbase
                      return curr
                  def _get_data_offset(self, prev):
                      """Returns the current offset in the (in-transaction) data file.
                      Versions < 2 of the revlog can get this 0(1), revlog v2 needs a docket
                      file to store that information: since sidedata can be rewritten to the
                      end of the data file within a transaction, you can have cases where, for
                      example, rev `n` does not have sidedata while rev `n - 1` does, leading
                      to `n - 1`'s sidedata being written after `n`'s data.
                      TODO cache this in a docket file before getting out of experimental."""
                      if self._docket is None:
                          return self.end(prev)
                      else:
                          return self._docket.data_end
                  def _writeentry(
                      self, transaction, entry, data, link, offset, sidedata, sidedata_offset
                  ):
                      # Files opened in a+ mode have inconsistent behavior on various
                      # platforms. Windows requires that a file positioning call be made
                      # when the file handle transitions between reads and writes. See
                      # 3686fa2b8eee and the mixedfilemodewrapper in windows.py. On other
                      # platforms, Python or the platform itself can be buggy. Some versions
                      # of Solaris have been observed to not append at the end of the file
                      # if the file was seeked to before the end. See issue4943 for more.
                      #
                      # We work around this issue by inserting a seek() before writing.
                      # Note: This is likely not necessary on Python 3. However, because
                      # the file handle is reused for reads and may be seeked there, we need
                      # to be careful before changing this.
                      if self._writinghandles is None:
                          msg = b'adding revision outside `revlog._writing` context'
                          raise error.ProgrammingError(msg)
                      ifh, dfh, sdfh = self._writinghandles
                      if self._docket is None:
                          ifh.seek(0, os.SEEK_END)
                      else:
                          ifh.seek(self._docket.index_end, os.SEEK_SET)
                      if dfh:
                          if self._docket is None:
                              dfh.seek(0, os.SEEK_END)
                          else:
                              dfh.seek(self._docket.data_end, os.SEEK_SET)
                      if sdfh:
                          sdfh.seek(self._docket.sidedata_end, os.SEEK_SET)
                      curr = len(self) - 1
                      if not self._inline:
                          transaction.add(self._datafile, offset)
                          if self._sidedatafile:
                              transaction.add(self._sidedatafile, sidedata_offset)
                          transaction.add(self._indexfile, curr * len(entry))
                          if data[0]:
                              dfh.write(data[0])
                          dfh.write(data[1])
                          if sidedata:
                              sdfh.write(sidedata)
                          ifh.write(entry)
                      else:
                          offset += curr * self.index.entry_size
                          transaction.add(self._indexfile, offset)
                          ifh.write(entry)
                          ifh.write(data[0])
                          ifh.write(data[1])
                          assert not sidedata
                          self._enforceinlinesize(transaction)
                      if self._docket is not None:
                          # revlog-v2 always has 3 writing handles, help Pytype
                          wh1 = self._writinghandles[0]
                          wh2 = self._writinghandles[1]
                          wh3 = self._writinghandles[2]
                          assert wh1 is not None
                          assert wh2 is not None
                          assert wh3 is not None
                          self._docket.index_end = wh1.tell()
                          self._docket.data_end = wh2.tell()
                          self._docket.sidedata_end = wh3.tell()
                      nodemaputil.setup_persistent_nodemap(transaction, self)
                  def addgroup(
                      self,
                      deltas,
                      linkmapper,
                      transaction,
                      alwayscache=False,
                      addrevisioncb=None,
                      duplicaterevisioncb=None,
                      debug_info=None,
                      delta_base_reuse_policy=None,
                  ):
                      """
                      add a delta group
                      given a set of deltas, add them to the revision log. the
                      first delta is against its parent, which should be in our
                      log, the rest are against the previous delta.
                      If ``addrevisioncb`` is defined, it will be called with arguments of
                      this revlog and the node that was added.
                      """
                      if self._adding_group:
                          raise error.ProgrammingError(b'cannot nest addgroup() calls')
                      # read the default delta-base reuse policy from revlog config if the
                      # group did not specify one.
                      if delta_base_reuse_policy is None:
                          if self._generaldelta and self._lazydeltabase:
                              delta_base_reuse_policy = DELTA_BASE_REUSE_TRY
                          else:
                              delta_base_reuse_policy = DELTA_BASE_REUSE_NO
                      self._adding_group = True
                      empty = True
                      try:
                          with self._writing(transaction):
                              write_debug = None
                              if self._debug_delta:
                                  write_debug = transaction._report
                              deltacomputer = deltautil.deltacomputer(
                                  self,
                                  write_debug=write_debug,
                                  debug_info=debug_info,
                              )
                              # loop through our set of deltas
                              for data in deltas:
                                  (
                                      node,
                                      p1,
                                      p2,
                                      linknode,
                                      deltabase,
                                      delta,
                                      flags,
                                      sidedata,
                                  ) = data
                                  link = linkmapper(linknode)
                                  flags = flags or REVIDX_DEFAULT_FLAGS
                                  rev = self.index.get_rev(node)
                                  if rev is not None:
                                      # this can happen if two branches make the same change
                                      self._nodeduplicatecallback(transaction, rev)
                                      if duplicaterevisioncb:
                                          duplicaterevisioncb(self, rev)
                                      empty = False
                                      continue
                                  for p in (p1, p2):
                                      if not self.index.has_node(p):
                                          raise error.LookupError(
                                              p, self.radix, _(b'unknown parent')
                                          )
                                  if not self.index.has_node(deltabase):
                                      raise error.LookupError(
                                          deltabase, self.display_id, _(b'unknown delta base')
                                      )
                                  baserev = self.rev(deltabase)
                                  if baserev != nullrev and self.iscensored(baserev):
                                      # if base is censored, delta must be full replacement in a
                                      # single patch operation
                                      hlen = struct.calcsize(b">lll")
                                      oldlen = self.rawsize(baserev)
                                      newlen = len(delta) - hlen
                                      if delta[:hlen] != mdiff.replacediffheader(
                                          oldlen, newlen
                                      ):
                                          raise error.CensoredBaseError(
                                              self.display_id, self.node(baserev)
                                          )
                                  if not flags and self._peek_iscensored(baserev, delta):
                                      flags |= REVIDX_ISCENSORED
                                  # We assume consumers of addrevisioncb will want to retrieve
                                  # the added revision, which will require a call to
                                  # revision(). revision() will fast path if there is a cache
                                  # hit. So, we tell _addrevision() to always cache in this case.
                                  # We're only using addgroup() in the context of changegroup
                                  # generation so the revision data can always be handled as raw
                                  # by the flagprocessor.
                                  rev = self._addrevision(
                                      node,
                                      None,
                                      transaction,
                                      link,
                                      p1,
                                      p2,
                                      flags,
                                      (baserev, delta, delta_base_reuse_policy),
                                      alwayscache=alwayscache,
                                      deltacomputer=deltacomputer,
                                      sidedata=sidedata,
                                  )
                                  if addrevisioncb:
                                      addrevisioncb(self, rev)
                                  empty = False
                      finally:
                          self._adding_group = False
                      return not empty
                  def iscensored(self, rev):
                      """Check if a file revision is censored."""
                      if not self._censorable:
                          return False
                      return self.flags(rev) & REVIDX_ISCENSORED
                  def _peek_iscensored(self, baserev, delta):
                      """Quickly check if a delta produces a censored revision."""
                      if not self._censorable:
                          return False
                      return storageutil.deltaiscensored(delta, baserev, self.rawsize)
                  def getstrippoint(self, minlink):
                      """find the minimum rev that must be stripped to strip the linkrev
                      Returns a tuple containing the minimum rev and a set of all revs that
                      have linkrevs that will be broken by this strip.
                      """
                      return storageutil.resolvestripinfo(
                          minlink,
                          len(self) - 1,
                          self.headrevs(),
                          self.linkrev,
                          self.parentrevs,
                      )
                  def strip(self, minlink, transaction):
                      """truncate the revlog on the first revision with a linkrev >= minlink
                      This function is called when we're stripping revision minlink and
                      its descendants from the repository.
                      We have to remove all revisions with linkrev >= minlink, because
                      the equivalent changelog revisions will be renumbered after the
                      strip.
                      So we truncate the revlog on the first of these revisions, and
                      trust that the caller has saved the revisions that shouldn't be
                      removed and that it'll re-add them after this truncation.
                      """
                      if len(self) == 0:
                          return
                      rev, _ = self.getstrippoint(minlink)
                      if rev == len(self):
                          return
                      # first truncate the files on disk
                      data_end = self.start(rev)
                      if not self._inline:
                          transaction.add(self._datafile, data_end)
                          end = rev * self.index.entry_size
                      else:
                          end = data_end + (rev * self.index.entry_size)
                      if self._sidedatafile:
                          sidedata_end = self.sidedata_cut_off(rev)
                          transaction.add(self._sidedatafile, sidedata_end)
                      transaction.add(self._indexfile, end)
                      if self._docket is not None:
                          # XXX we could, leverage the docket while stripping. However it is
                          # not powerfull enough at the time of this comment
                          self._docket.index_end = end
                          self._docket.data_end = data_end
                          self._docket.sidedata_end = sidedata_end
                          self._docket.write(transaction, stripping=True)
                      # then reset internal state in memory to forget those revisions
                      self._revisioncache = None
                      self._chaininfocache = util.lrucachedict(500)
                      self._segmentfile.clear_cache()
                      self._segmentfile_sidedata.clear_cache()
                      del self.index[rev:-1]
                  def checksize(self):
                      """Check size of index and data files
                      return a (dd, di) tuple.
                      - dd: extra bytes for the "data" file
                      - di: extra bytes for the "index" file
                      A healthy revlog will return (0, 0).
                      """
                      expected = 0
                      if len(self):
                          expected = max(0, self.end(len(self) - 1))
                      try:
                          with self._datafp() as f:
                              f.seek(0, io.SEEK_END)
                              actual = f.tell()
                          dd = actual - expected
                      except FileNotFoundError:
                          dd = 0
                      try:
                          f = self.opener(self._indexfile)
                          f.seek(0, io.SEEK_END)
                          actual = f.tell()
                          f.close()
                          s = self.index.entry_size
                          i = max(0, actual // s)
                          di = actual - (i * s)
                          if self._inline:
                              databytes = 0
                              for r in self:
                                  databytes += max(0, self.length(r))
                              dd = 0
                              di = actual - len(self) * s - databytes
                      except FileNotFoundError:
                          di = 0
                      return (dd, di)
                  def files(self):
                      res = [self._indexfile]
                      if self._docket_file is None:
                          if not self._inline:
                              res.append(self._datafile)
                      else:
                          res.append(self._docket_file)
                          res.extend(self._docket.old_index_filepaths(include_empty=False))
                          if self._docket.data_end:
                              res.append(self._datafile)
                          res.extend(self._docket.old_data_filepaths(include_empty=False))
                          if self._docket.sidedata_end:
                              res.append(self._sidedatafile)
                          res.extend(self._docket.old_sidedata_filepaths(include_empty=False))
                      return res
                  def emitrevisions(
                      self,
                      nodes,
                      nodesorder=None,
                      revisiondata=False,
                      assumehaveparentrevisions=False,
                      deltamode=repository.CG_DELTAMODE_STD,
                      sidedata_helpers=None,
                      debug_info=None,
                  ):
                      if nodesorder not in (b'nodes', b'storage', b'linear', None):
                          raise error.ProgrammingError(
                              b'unhandled value for nodesorder: %s' % nodesorder
                          )
                      if nodesorder is None and not self._generaldelta:
                          nodesorder = b'storage'
                      if (
                          not self._storedeltachains
                          and deltamode != repository.CG_DELTAMODE_PREV
                      ):
                          deltamode = repository.CG_DELTAMODE_FULL
                      return storageutil.emitrevisions(
                          self,
                          nodes,
                          nodesorder,
                          revlogrevisiondelta,
                          deltaparentfn=self.deltaparent,
                          candeltafn=self.candelta,
                          rawsizefn=self.rawsize,
                          revdifffn=self.revdiff,
                          flagsfn=self.flags,
                          deltamode=deltamode,
                          revisiondata=revisiondata,
                          assumehaveparentrevisions=assumehaveparentrevisions,
                          sidedata_helpers=sidedata_helpers,
                          debug_info=debug_info,
                      )
                  DELTAREUSEALWAYS = b'always'
                  DELTAREUSESAMEREVS = b'samerevs'
                  DELTAREUSENEVER = b'never'
                  DELTAREUSEFULLADD = b'fulladd'
                  DELTAREUSEALL = {b'always', b'samerevs', b'never', b'fulladd'}
                  def clone(
                      self,
                      tr,
                      destrevlog,
                      addrevisioncb=None,
                      deltareuse=DELTAREUSESAMEREVS,
                      forcedeltabothparents=None,
                      sidedata_helpers=None,
                  ):
                      """Copy this revlog to another, possibly with format changes.
                      The destination revlog will contain the same revisions and nodes.
                      However, it may not be bit-for-bit identical due to e.g. delta encoding
                      differences.
                      The ``deltareuse`` argument control how deltas from the existing revlog
                      are preserved in the destination revlog. The argument can have the
                      following values:
                      DELTAREUSEALWAYS
                         Deltas will always be reused (if possible), even if the destination
                         revlog would not select the same revisions for the delta. This is the
                         fastest mode of operation.
                      DELTAREUSESAMEREVS
                         Deltas will be reused if the destination revlog would pick the same
                         revisions for the delta. This mode strikes a balance between speed
                         and optimization.
                      DELTAREUSENEVER
                         Deltas will never be reused. This is the slowest mode of execution.
                         This mode can be used to recompute deltas (e.g. if the diff/delta
                         algorithm changes).
                      DELTAREUSEFULLADD
                         Revision will be re-added as if their were new content. This is
                         slower than DELTAREUSEALWAYS but allow more mechanism to kicks in.
                         eg: large file detection and handling.
                      Delta computation can be slow, so the choice of delta reuse policy can
                      significantly affect run time.
                      The default policy (``DELTAREUSESAMEREVS``) strikes a balance between
                      two extremes. Deltas will be reused if they are appropriate. But if the
                      delta could choose a better revision, it will do so. This means if you
                      are converting a non-generaldelta revlog to a generaldelta revlog,
                      deltas will be recomputed if the delta's parent isn't a parent of the
                      revision.
                      In addition to the delta policy, the ``forcedeltabothparents``
                      argument controls whether to force compute deltas against both parents
                      for merges. By default, the current default is used.
                      See `revlogutil.sidedata.get_sidedata_helpers` for the doc on
                      `sidedata_helpers`.
                      """
                      if deltareuse not in self.DELTAREUSEALL:
                          raise ValueError(
                              _(b'value for deltareuse invalid: %s') % deltareuse
                          )
                      if len(destrevlog):
                          raise ValueError(_(b'destination revlog is not empty'))
                      if getattr(self, 'filteredrevs', None):
                          raise ValueError(_(b'source revlog has filtered revisions'))
                      if getattr(destrevlog, 'filteredrevs', None):
                          raise ValueError(_(b'destination revlog has filtered revisions'))
                      # lazydelta and lazydeltabase controls whether to reuse a cached delta,
                      # if possible.
                      oldlazydelta = destrevlog._lazydelta
                      oldlazydeltabase = destrevlog._lazydeltabase
                      oldamd = destrevlog._deltabothparents
                      try:
                          if deltareuse == self.DELTAREUSEALWAYS:
                              destrevlog._lazydeltabase = True
                              destrevlog._lazydelta = True
                          elif deltareuse == self.DELTAREUSESAMEREVS:
                              destrevlog._lazydeltabase = False
                              destrevlog._lazydelta = True
                          elif deltareuse == self.DELTAREUSENEVER:
                              destrevlog._lazydeltabase = False
                              destrevlog._lazydelta = False
                          destrevlog._deltabothparents = forcedeltabothparents or oldamd
                          self._clone(
                              tr,
                              destrevlog,
                              addrevisioncb,
                              deltareuse,
                              forcedeltabothparents,
                              sidedata_helpers,
                          )
                      finally:
                          destrevlog._lazydelta = oldlazydelta
                          destrevlog._lazydeltabase = oldlazydeltabase
                          destrevlog._deltabothparents = oldamd
                  def _clone(
                      self,
                      tr,
                      destrevlog,
                      addrevisioncb,
                      deltareuse,
                      forcedeltabothparents,
                      sidedata_helpers,
                  ):
                      """perform the core duty of `revlog.clone` after parameter processing"""
                      write_debug = None
                      if self._debug_delta:
                          write_debug = tr._report
                      deltacomputer = deltautil.deltacomputer(
                          destrevlog,
                          write_debug=write_debug,
                      )
                      index = self.index
                      for rev in self:
                          entry = index[rev]
                          # Some classes override linkrev to take filtered revs into
                          # account. Use raw entry from index.
                          flags = entry[0] & 0xFFFF
                          linkrev = entry[4]
                          p1 = index[entry[5]][7]
                          p2 = index[entry[6]][7]
                          node = entry[7]
                          # (Possibly) reuse the delta from the revlog if allowed and
                          # the revlog chunk is a delta.
                          cachedelta = None
                          rawtext = None
                          if deltareuse == self.DELTAREUSEFULLADD:
                              text = self._revisiondata(rev)
                              sidedata = self.sidedata(rev)
                              if sidedata_helpers is not None:
                                  (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
                                      self, sidedata_helpers, sidedata, rev
                                  )
                                  flags = flags | new_flags[0] & ~new_flags[1]
                              destrevlog.addrevision(
                                  text,
                                  tr,
                                  linkrev,
                                  p1,
                                  p2,
                                  cachedelta=cachedelta,
                                  node=node,
                                  flags=flags,
                                  deltacomputer=deltacomputer,
                                  sidedata=sidedata,
                              )
                          else:
                              if destrevlog._lazydelta:
                                  dp = self.deltaparent(rev)
                                  if dp != nullrev:
                                      cachedelta = (dp, bytes(self._chunk(rev)))
                              sidedata = None
                              if not cachedelta:
                                  rawtext = self._revisiondata(rev)
                                  sidedata = self.sidedata(rev)
                              if sidedata is None:
                                  sidedata = self.sidedata(rev)
                              if sidedata_helpers is not None:
                                  (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
                                      self, sidedata_helpers, sidedata, rev
                                  )
                                  flags = flags | new_flags[0] & ~new_flags[1]
                              with destrevlog._writing(tr):
                                  destrevlog._addrevision(
                                      node,
                                      rawtext,
                                      tr,
                                      linkrev,
                                      p1,
                                      p2,
                                      flags,
                                      cachedelta,
                                      deltacomputer=deltacomputer,
                                      sidedata=sidedata,
                                  )
                          if addrevisioncb:
                              addrevisioncb(self, rev, node)
                  def censorrevision(self, tr, censornode, tombstone=b''):
                      if self._format_version == REVLOGV0:
                          raise error.RevlogError(
                              _(b'cannot censor with version %d revlogs')
                              % self._format_version
                          )
                      elif self._format_version == REVLOGV1:
                          rewrite.v1_censor(self, tr, censornode, tombstone)
                      else:
                          rewrite.v2_censor(self, tr, censornode, tombstone)
                  def verifyintegrity(self, state):
                      """Verifies the integrity of the revlog.
                      Yields ``revlogproblem`` instances describing problems that are
                      found.
                      """
                      dd, di = self.checksize()
                      if dd:
                          yield revlogproblem(error=_(b'data length off by %d bytes') % dd)
                      if di:
                          yield revlogproblem(error=_(b'index contains %d extra bytes') % di)
                      version = self._format_version
                      # The verifier tells us what version revlog we should be.
                      if version != state[b'expectedversion']:
                          yield revlogproblem(
                              warning=_(b"warning: '%s' uses revlog format %d; expected %d")
                              % (self.display_id, version, state[b'expectedversion'])
                          )
                      state[b'skipread'] = set()
                      state[b'safe_renamed'] = set()
                      for rev in self:
                          node = self.node(rev)
                          # Verify contents. 4 cases to care about:
                          #
                          #   common: the most common case
                          #   rename: with a rename
                          #   meta: file content starts with b'\1\n', the metadata
                          #         header defined in filelog.py, but without a rename
                          #   ext: content stored externally
                          #
                          # More formally, their differences are shown below:
                          #
                          #                       | common | rename | meta  | ext
                          #  -------------------------------------------------------
                          #   flags()             | 0      | 0      | 0     | not 0
                          #   renamed()           | False  | True   | False | ?
                          #   rawtext[0:2]=='\1\n'| False  | True   | True  | ?
                          #
                          # "rawtext" means the raw text stored in revlog data, which
                          # could be retrieved by "rawdata(rev)". "text"
                          # mentioned below is "revision(rev)".
                          #
                          # There are 3 different lengths stored physically:
                          #  1. L1: rawsize, stored in revlog index
                          #  2. L2: len(rawtext), stored in revlog data
                          #  3. L3: len(text), stored in revlog data if flags==0, or
                          #     possibly somewhere else if flags!=0
                          #
                          # L1 should be equal to L2. L3 could be different from them.
                          # "text" may or may not affect commit hash depending on flag
                          # processors (see flagutil.addflagprocessor).
                          #
                          #              | common  | rename | meta  | ext
                          # -------------------------------------------------
                          #    rawsize() | L1      | L1     | L1    | L1
                          #       size() | L1      | L2-LM  | L1(*) | L1 (?)
                          # len(rawtext) | L2      | L2     | L2    | L2
                          #    len(text) | L2      | L2     | L2    | L3
                          #  len(read()) | L2      | L2-LM  | L2-LM | L3 (?)
                          #
                          # LM:  length of metadata, depending on rawtext
                          # (*): not ideal, see comment in filelog.size
                          # (?): could be "- len(meta)" if the resolved content has
                          #      rename metadata
                          #
                          # Checks needed to be done:
                          #  1. length check: L1 == L2, in all cases.
                          #  2. hash check: depending on flag processor, we may need to
                          #     use either "text" (external), or "rawtext" (in revlog).
                          try:
                              skipflags = state.get(b'skipflags', 0)
                              if skipflags:
                                  skipflags &= self.flags(rev)
                              _verify_revision(self, skipflags, state, node)
                              l1 = self.rawsize(rev)
                              l2 = len(self.rawdata(node))
                              if l1 != l2:
                                  yield revlogproblem(
                                      error=_(b'unpacked size is %d, %d expected') % (l2, l1),
                                      node=node,
                                  )
                          except error.CensoredNodeError:
                              if state[b'erroroncensored']:
                                  yield revlogproblem(
                                      error=_(b'censored file data'), node=node
                                  )
                                  state[b'skipread'].add(node)
                          except Exception as e:
                              yield revlogproblem(
                                  error=_(b'unpacking %s: %s')
                                  % (short(node), stringutil.forcebytestr(e)),
                                  node=node,
                              )
                              state[b'skipread'].add(node)
                  def storageinfo(
                      self,
                      exclusivefiles=False,
                      sharedfiles=False,
                      revisionscount=False,
                      trackedsize=False,
                      storedsize=False,
                  ):
                      d = {}
                      if exclusivefiles:
                          d[b'exclusivefiles'] = [(self.opener, self._indexfile)]
                          if not self._inline:
                              d[b'exclusivefiles'].append((self.opener, self._datafile))
                      if sharedfiles:
                          d[b'sharedfiles'] = []
                      if revisionscount:
                          d[b'revisionscount'] = len(self)
                      if trackedsize:
                          d[b'trackedsize'] = sum(map(self.rawsize, iter(self)))
                      if storedsize:
                          d[b'storedsize'] = sum(
                              self.opener.stat(path).st_size for path in self.files()
                          )
                      return d
                  def rewrite_sidedata(self, transaction, helpers, startrev, endrev):
                      if not self.hassidedata:
                          return
                      # revlog formats with sidedata support does not support inline
                      assert not self._inline
                      if not helpers[1] and not helpers[2]:
                          # Nothing to generate or remove
                          return
                      new_entries = []
                      # append the new sidedata
                      with self._writing(transaction):
                          ifh, dfh, sdfh = self._writinghandles
                          dfh.seek(self._docket.sidedata_end, os.SEEK_SET)
                          current_offset = sdfh.tell()
                          for rev in range(startrev, endrev + 1):
                              entry = self.index[rev]
                              new_sidedata, flags = sidedatautil.run_sidedata_helpers(
                                  store=self,
                                  sidedata_helpers=helpers,
                                  sidedata={},
                                  rev=rev,
                              )
                              serialized_sidedata = sidedatautil.serialize_sidedata(
                                  new_sidedata
                              )
                              sidedata_compression_mode = COMP_MODE_INLINE
                              if serialized_sidedata and self.hassidedata:
                                  sidedata_compression_mode = COMP_MODE_PLAIN
                                  h, comp_sidedata = self.compress(serialized_sidedata)
                                  if (
                                      h != b'u'
                                      and comp_sidedata[0] != b'\0'
                                      and len(comp_sidedata) < len(serialized_sidedata)
                                  ):
                                      assert not h
                                      if (
                                          comp_sidedata[0]
                                          == self._docket.default_compression_header
                                      ):
                                          sidedata_compression_mode = COMP_MODE_DEFAULT
                                          serialized_sidedata = comp_sidedata
                                      else:
                                          sidedata_compression_mode = COMP_MODE_INLINE
                                          serialized_sidedata = comp_sidedata
                              if entry[8] != 0 or entry[9] != 0:
                                  # rewriting entries that already have sidedata is not
                                  # supported yet, because it introduces garbage data in the
                                  # revlog.
                                  msg = b"rewriting existing sidedata is not supported yet"
                                  raise error.Abort(msg)
                              # Apply (potential) flags to add and to remove after running
                              # the sidedata helpers
                              new_offset_flags = entry[0] | flags[0] & ~flags[1]
                              entry_update = (
                                  current_offset,
                                  len(serialized_sidedata),
                                  new_offset_flags,
                                  sidedata_compression_mode,
                              )
                              # the sidedata computation might have move the file cursors around
                              sdfh.seek(current_offset, os.SEEK_SET)
                              sdfh.write(serialized_sidedata)
                              new_entries.append(entry_update)
                              current_offset += len(serialized_sidedata)
                              self._docket.sidedata_end = sdfh.tell()
                          # rewrite the new index entries
                          ifh.seek(startrev * self.index.entry_size)
                          for i, e in enumerate(new_entries):
                              rev = startrev + i
                              self.index.replace_sidedata_info(rev, *e)
                              packed = self.index.entry_binary(rev)
                              if rev == 0 and self._docket is None:
                                  header = self._format_flags | self._format_version
                                  header = self.index.pack_header(header)
                                  packed = header + packed
                              ifh.write(packed)

mercurial/store.py

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

mercurial/util.py

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

mercurial/utils/dateutil.py

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

mercurial/utils/resourceutil.py

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

mercurial/vfs.py

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

relnotes/6.5

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-bundle-phase-internal.t

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-revlog-delta-find.t

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-server-view.t

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tests/test-transaction-rollback-on-revlog-split.t

0 0 0

	1		NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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