upstream/mercurial-mirror Commit - r51829:6408777c

branching: merge stable into default

Raphaël Gomès -

r51829:6408777c default

parent child

.hgsigs

0 +1 0

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

.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
+a8b5420103937fca97c584c5162178eed828ada 6.5.2

mercurial/transaction.py

0 +4 -3

              # transaction.py - simple journaling scheme for mercurial
              #
              # This transaction scheme is intended to gracefully handle program
              # errors and interruptions. More serious failures like system crashes
              # can be recovered with an fsck-like tool. As the whole repository is
              # effectively log-structured, this should amount to simply truncating
              # anything that isn't referenced in the changelog.
              #
              # Copyright 2005, 2006 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 errno
              import os
              from .i18n import _
              from . import (
+                 encoding,
                  error,
                  pycompat,
                  util,
              )
              from .utils import stringutil
              version = 2
              GEN_GROUP_ALL = b'all'
              GEN_GROUP_PRE_FINALIZE = b'prefinalize'
              GEN_GROUP_POST_FINALIZE = b'postfinalize'
              def active(func):
                  def _active(self, *args, **kwds):
                      if self._count == 0:
                          raise error.ProgrammingError(
                              b'cannot use transaction when it is already committed/aborted'
                          )
                      return func(self, *args, **kwds)
                  return _active
              UNDO_BACKUP = b'%s.backupfiles'
              UNDO_FILES_MAY_NEED_CLEANUP = [
                  # legacy entries that might exists on disk from previous version:
                  (b'store', b'%s.narrowspec'),
                  (b'plain', b'%s.narrowspec.dirstate'),
                  (b'plain', b'%s.branch'),
                  (b'plain', b'%s.bookmarks'),
                  (b'store', b'%s.phaseroots'),
                  (b'plain', b'%s.dirstate'),
                  # files actually in uses today:
                  (b'plain', b'%s.desc'),
                  # Always delete undo last to make sure we detect that a clean up is needed if
                  # the process is interrupted.
                  (b'store', b'%s'),
              ]
              def cleanup_undo_files(report, vfsmap, undo_prefix=b'undo'):
                  """remove "undo" files used by the rollback logic
                  This is useful to prevent rollback running in situation were it does not
                  make sense. For example after a strip.
                  """
                  backup_listing = UNDO_BACKUP % undo_prefix
                  backup_entries = []
                  undo_files = []
                  svfs = vfsmap[b'store']
                  try:
                      with svfs(backup_listing) as f:
                          backup_entries = read_backup_files(report, f)
                  except OSError as e:
                      if e.errno != errno.ENOENT:
                          msg = _(b'could not read %s: %s\n')
                          msg %= (svfs.join(backup_listing), stringutil.forcebytestr(e))
                          report(msg)
                  for location, f, backup_path, c in backup_entries:
                      if location in vfsmap and backup_path:
                          undo_files.append((vfsmap[location], backup_path))
                  undo_files.append((svfs, backup_listing))
                  for location, undo_path in UNDO_FILES_MAY_NEED_CLEANUP:
                      undo_files.append((vfsmap[location], undo_path % undo_prefix))
                  for undovfs, undofile in undo_files:
                      try:
                          undovfs.unlink(undofile)
                      except OSError as e:
                          if e.errno != errno.ENOENT:
                              msg = _(b'error removing %s: %s\n')
                              msg %= (undovfs.join(undofile), stringutil.forcebytestr(e))
                              report(msg)
              def _playback(
                  journal,
                  report,
                  opener,
                  vfsmap,
                  entries,
                  backupentries,
                  unlink=True,
                  checkambigfiles=None,
              ):
                  """rollback a transaction :
                  - truncate files that have been appended to
                  - restore file backups
                  - delete temporary files
                  """
                  backupfiles = []
                  def restore_one_backup(vfs, f, b, checkambig):
                      filepath = vfs.join(f)
                      backuppath = vfs.join(b)
                      try:
                          util.copyfile(backuppath, filepath, checkambig=checkambig)
                          backupfiles.append((vfs, b))
                      except IOError as exc:
                          e_msg = stringutil.forcebytestr(exc)
                          report(_(b"failed to recover %s (%s)\n") % (f, e_msg))
                          raise
                  # gather all backup files that impact the store
                  # (we need this to detect files that are both backed up and truncated)
                  store_backup = {}
                  for entry in backupentries:
                      location, file_path, backup_path, cache = entry
                      vfs = vfsmap[location]
                      is_store = vfs.join(b'') == opener.join(b'')
                      if is_store and file_path and backup_path:
                          store_backup[file_path] = entry
                  copy_done = set()
                  # truncate all file `f` to offset `o`
                  for f, o in sorted(dict(entries).items()):
                      # if we have a backup for `f`, we should restore it first and truncate
                      # the restored file
                      bck_entry = store_backup.get(f)
                      if bck_entry is not None:
                          location, file_path, backup_path, cache = bck_entry
                          checkambig = False
                          if checkambigfiles:
                              checkambig = (file_path, location) in checkambigfiles
                          restore_one_backup(opener, file_path, backup_path, checkambig)
                          copy_done.add(bck_entry)
                      # truncate the file to its pre-transaction size
                      if o or not unlink:
                          checkambig = checkambigfiles and (f, b'') in checkambigfiles
                          try:
                              fp = opener(f, b'a', checkambig=checkambig)
                              if fp.tell() < o:
                                  raise error.Abort(
                                      _(
                                          b"attempted to truncate %s to %d bytes, but it was "
                                          b"already %d bytes\n"
                                      )
                                      % (f, o, fp.tell())
                                  )
                              fp.truncate(o)
                              fp.close()
                          except IOError:
                              report(_(b"failed to truncate %s\n") % f)
                              raise
                      else:
                          # delete empty file
                          try:
                              opener.unlink(f)
                          except FileNotFoundError:
                              pass
                  # restore backed up files and clean up temporary files
                  for entry in backupentries:
                      if entry in copy_done:
                          continue
                      l, f, b, c = entry
                      if l not in vfsmap and c:
                          report(b"couldn't handle %s: unknown cache location %s\n" % (b, l))
                      vfs = vfsmap[l]
                      try:
                          checkambig = checkambigfiles and (f, l) in checkambigfiles
                          if f and b:
                              restore_one_backup(vfs, f, b, checkambig)
                          else:
                              target = f or b
                              try:
                                  vfs.unlink(target)
                              except FileNotFoundError:
                                  # This is fine because
                                  #
                                  # either we are trying to delete the main file, and it is
                                  # already deleted.
                                  #
                                  # or we are trying to delete a temporary file and it is
                                  # already deleted.
                                  #
                                  # in both case, our target result (delete the file) is
                                  # already achieved.
                                  pass
                      except (IOError, OSError, error.Abort):
                          if not c:
                              raise
                  # cleanup transaction state file and the backups file
                  backuppath = b"%s.backupfiles" % journal
                  if opener.exists(backuppath):
                      opener.unlink(backuppath)
                  opener.unlink(journal)
                  try:
                      for vfs, f in backupfiles:
                          if vfs.exists(f):
                              vfs.unlink(f)
                  except (IOError, OSError, error.Abort):
                      # only pure backup file remains, it is sage to ignore any error
                      pass
              class transaction(util.transactional):
                  def __init__(
                      self,
                      report,
                      opener,
                      vfsmap,
                      journalname,
                      undoname=None,
                      after=None,
                      createmode=None,
                      validator=None,
                      releasefn=None,
                      checkambigfiles=None,
-                     name='<unnamed>',
+                     name=b'<unnamed>',
                  ):
                      """Begin a new transaction
                      Begins a new transaction that allows rolling back writes in the event of
                      an exception.
                      * `after`: called after the transaction has been committed
                      * `createmode`: the mode of the journal file that will be created
                      * `releasefn`: called after releasing (with transaction and result)
                      `checkambigfiles` is a set of (path, vfs-location) tuples,
                      which determine whether file stat ambiguity should be avoided
                      for corresponded files.
                      """
                      self._count = 1
                      self._usages = 1
                      self._report = report
                      # a vfs to the store content
                      self._opener = opener
                      # a map to access file in various {location -> vfs}
                      vfsmap = vfsmap.copy()
                      vfsmap[b''] = opener  # set default value
                      self._vfsmap = vfsmap
                      self._after = after
                      self._offsetmap = {}
                      self._newfiles = set()
                      self._journal = journalname
                      self._journal_files = []
                      self._undoname = undoname
                      self._queue = []
                      # A callback to do something just after releasing transaction.
                      if releasefn is None:
                          releasefn = lambda tr, success: None
                      self._releasefn = releasefn
                      self._checkambigfiles = set()
                      if checkambigfiles:
                          self._checkambigfiles.update(checkambigfiles)
                      self._names = [name]
                      # A dict dedicated to precisely tracking the changes introduced in the
                      # transaction.
                      self.changes = {}
                      # a dict of arguments to be passed to hooks
                      self.hookargs = {}
                      self._file = opener.open(self._journal, b"w+")
                      # a list of ('location', 'path', 'backuppath', cache) entries.
                      # - if 'backuppath' is empty, no file existed at backup time
                      # - if 'path' is empty, this is a temporary transaction file
                      # - if 'location' is not empty, the path is outside main opener reach.
                      #   use 'location' value as a key in a vfsmap to find the right 'vfs'
                      # (cache is currently unused)
                      self._backupentries = []
                      self._backupmap = {}
                      self._backupjournal = b"%s.backupfiles" % self._journal
                      self._backupsfile = opener.open(self._backupjournal, b'w')
                      self._backupsfile.write(b'%d\n' % version)
                      # the set of temporary files
                      self._tmp_files = set()
                      if createmode is not None:
                          opener.chmod(self._journal, createmode & 0o666)
                          opener.chmod(self._backupjournal, createmode & 0o666)
                      # hold file generations to be performed on commit
                      self._filegenerators = {}
                      # hold callback to write pending data for hooks
                      self._pendingcallback = {}
                      # True is any pending data have been written ever
                      self._anypending = False
                      # holds callback to call when writing the transaction
                      self._finalizecallback = {}
                      # holds callback to call when validating the transaction
                      # should raise exception if anything is wrong
                      self._validatecallback = {}
                      if validator is not None:
                          self._validatecallback[b'001-userhooks'] = validator
                      # hold callback for post transaction close
                      self._postclosecallback = {}
                      # holds callbacks to call during abort
                      self._abortcallback = {}
                  def __repr__(self):
                      name = b'/'.join(self._names)
                      return '<transaction name=%s, count=%d, usages=%d>' % (
-                         name,
+                         encoding.strfromlocal(name),
                          self._count,
                          self._usages,
                      )
                  def __del__(self):
                      if self._journal:
                          self._abort()
                  @property
                  def finalized(self):
                      return self._finalizecallback is None
                  @active
                  def startgroup(self):
                      """delay registration of file entry
                      This is used by strip to delay vision of strip offset. The transaction
                      sees either none or all of the strip actions to be done."""
                      self._queue.append([])
                  @active
                  def endgroup(self):
                      """apply delayed registration of file entry.
                      This is used by strip to delay vision of strip offset. The transaction
                      sees either none or all of the strip actions to be done."""
                      q = self._queue.pop()
                      for f, o in q:
                          self._addentry(f, o)
                  @active
                  def add(self, file, offset):
                      """record the state of an append-only file before update"""
                      if (
                          file in self._newfiles
                          or file in self._offsetmap
                          or file in self._backupmap
                          or file in self._tmp_files
                      ):
                          return
                      if self._queue:
                          self._queue[-1].append((file, offset))
                          return
                      self._addentry(file, offset)
                  def _addentry(self, file, offset):
                      """add a append-only entry to memory and on-disk state"""
                      if (
                          file in self._newfiles
                          or file in self._offsetmap
                          or file in self._backupmap
                          or file in self._tmp_files
                      ):
                          return
                      if offset:
                          self._offsetmap[file] = offset
                      else:
                          self._newfiles.add(file)
                      # add enough data to the journal to do the truncate
                      self._file.write(b"%s\0%d\n" % (file, offset))
                      self._file.flush()
                  @active
                  def addbackup(self, file, hardlink=True, location=b'', for_offset=False):
                      """Adds a backup of the file to the transaction
                      Calling addbackup() creates a hardlink backup of the specified file
                      that is used to recover the file in the event of the transaction
                      aborting.
                      * `file`: the file path, relative to .hg/store
                      * `hardlink`: use a hardlink to quickly create the backup
                      If `for_offset` is set, we expect a offset for this file to have been previously recorded
                      """
                      if self._queue:
                          msg = b'cannot use transaction.addbackup inside "group"'
                          raise error.ProgrammingError(msg)
                      if file in self._newfiles or file in self._backupmap:
                          return
                      elif file in self._offsetmap and not for_offset:
                          return
                      elif for_offset and file not in self._offsetmap:
                          msg = (
                              'calling `addbackup` with `for_offmap=True`, '
                              'but no offset recorded: [%r] %r'
                          )
                          msg %= (location, file)
                          raise error.ProgrammingError(msg)
                      vfs = self._vfsmap[location]
                      dirname, filename = vfs.split(file)
                      backupfilename = b"%s.backup.%s.bck" % (self._journal, filename)
                      backupfile = vfs.reljoin(dirname, backupfilename)
                      if vfs.exists(file):
                          filepath = vfs.join(file)
                          backuppath = vfs.join(backupfile)
                          # store encoding may result in different directory here.
                          # so we have to ensure the destination directory exist
                          final_dir_name = os.path.dirname(backuppath)
                          util.makedirs(final_dir_name, mode=vfs.createmode, notindexed=True)
                          # then we can copy the backup
                          util.copyfile(filepath, backuppath, hardlink=hardlink)
                      else:
                          backupfile = b''
                      self._addbackupentry((location, file, backupfile, False))
                  def _addbackupentry(self, entry):
                      """register a new backup entry and write it to disk"""
                      self._backupentries.append(entry)
                      self._backupmap[entry[1]] = len(self._backupentries) - 1
                      self._backupsfile.write(b"%s\0%s\0%s\0%d\n" % entry)
                      self._backupsfile.flush()
                  @active
                  def registertmp(self, tmpfile, location=b''):
                      """register a temporary transaction file
                      Such files will be deleted when the transaction exits (on both
                      failure and success).
                      """
                      self._tmp_files.add(tmpfile)
                      self._addbackupentry((location, b'', tmpfile, False))
                  @active
                  def addfilegenerator(
                      self,
                      genid,
                      filenames,
                      genfunc,
                      order=0,
                      location=b'',
                      post_finalize=False,
                  ):
                      """add a function to generates some files at transaction commit
                      The `genfunc` argument is a function capable of generating proper
                      content of each entry in the `filename` tuple.
                      At transaction close time, `genfunc` will be called with one file
                      object argument per entries in `filenames`.
                      The transaction itself is responsible for the backup, creation and
                      final write of such file.
                      The `genid` argument is used to ensure the same set of file is only
                      generated once. Call to `addfilegenerator` for a `genid` already
                      present will overwrite the old entry.
                      The `order` argument may be used to control the order in which multiple
                      generator will be executed.
                      The `location` arguments may be used to indicate the files are located
                      outside of the the standard directory for transaction. It should match
                      one of the key of the `transaction.vfsmap` dictionary.
                      The `post_finalize` argument can be set to `True` for file generation
                      that must be run after the transaction has been finalized.
                      """
                      # For now, we are unable to do proper backup and restore of custom vfs
                      # but for bookmarks that are handled outside this mechanism.
                      entry = (order, filenames, genfunc, location, post_finalize)
                      self._filegenerators[genid] = entry
                  @active
                  def removefilegenerator(self, genid):
                      """reverse of addfilegenerator, remove a file generator function"""
                      if genid in self._filegenerators:
                          del self._filegenerators[genid]
                  def _generatefiles(self, suffix=b'', group=GEN_GROUP_ALL):
                      # write files registered for generation
                      any = False
                      if group == GEN_GROUP_ALL:
                          skip_post = skip_pre = False
                      else:
                          skip_pre = group == GEN_GROUP_POST_FINALIZE
                          skip_post = group == GEN_GROUP_PRE_FINALIZE
                      for id, entry in sorted(self._filegenerators.items()):
                          any = True
                          order, filenames, genfunc, location, post_finalize = entry
                          # for generation at closing, check if it's before or after finalize
                          if skip_post and post_finalize:
                              continue
                          elif skip_pre and not post_finalize:
                              continue
                          vfs = self._vfsmap[location]
                          files = []
                          try:
                              for name in filenames:
                                  name += suffix
                                  if suffix:
                                      self.registertmp(name, location=location)
                                      checkambig = False
                                  else:
                                      self.addbackup(name, location=location)
                                      checkambig = (name, location) in self._checkambigfiles
                                  files.append(
                                      vfs(name, b'w', atomictemp=True, checkambig=checkambig)
                                  )
                              genfunc(*files)
                              for f in files:
                                  f.close()
                              # skip discard() loop since we're sure no open file remains
                              del files[:]
                          finally:
                              for f in files:
                                  f.discard()
                      return any
                  @active
                  def findoffset(self, file):
                      if file in self._newfiles:
                          return 0
                      return self._offsetmap.get(file)
                  @active
                  def readjournal(self):
                      self._file.seek(0)
                      entries = []
                      for l in self._file.readlines():
                          file, troffset = l.split(b'\0')
                          entries.append((file, int(troffset)))
                      return entries
                  @active
                  def replace(self, file, offset):
                      """
                      replace can only replace already committed entries
                      that are not pending in the queue
                      """
                      if file in self._newfiles:
                          if not offset:
                              return
                          self._newfiles.remove(file)
                          self._offsetmap[file] = offset
                      elif file in self._offsetmap:
                          if not offset:
                              del self._offsetmap[file]
                              self._newfiles.add(file)
                          else:
                              self._offsetmap[file] = offset
                      else:
                          raise KeyError(file)
                      self._file.write(b"%s\0%d\n" % (file, offset))
                      self._file.flush()
                  @active
-                 def nest(self, name='<unnamed>'):
+                 def nest(self, name=b'<unnamed>'):
                      self._count += 1
                      self._usages += 1
                      self._names.append(name)
                      return self
                  def release(self):
                      if self._count > 0:
                          self._usages -= 1
                      if self._names:
                          self._names.pop()
                      # if the transaction scopes are left without being closed, fail
                      if self._count > 0 and self._usages == 0:
                          self._abort()
                  def running(self):
                      return self._count > 0
                  def addpending(self, category, callback):
                      """add a callback to be called when the transaction is pending
                      The transaction will be given as callback's first argument.
                      Category is a unique identifier to allow overwriting an old callback
                      with a newer callback.
                      """
                      self._pendingcallback[category] = callback
                  @active
                  def writepending(self):
                      """write pending file to temporary version
                      This is used to allow hooks to view a transaction before commit"""
                      categories = sorted(self._pendingcallback)
                      for cat in categories:
                          # remove callback since the data will have been flushed
                          any = self._pendingcallback.pop(cat)(self)
                          self._anypending = self._anypending or any
                      self._anypending |= self._generatefiles(suffix=b'.pending')
                      return self._anypending
                  @active
                  def hasfinalize(self, category):
                      """check is a callback already exist for a category"""
                      return category in self._finalizecallback
                  @active
                  def addfinalize(self, category, callback):
                      """add a callback to be called when the transaction is closed
                      The transaction will be given as callback's first argument.
                      Category is a unique identifier to allow overwriting old callbacks with
                      newer callbacks.
                      """
                      self._finalizecallback[category] = callback
                  @active
                  def addpostclose(self, category, callback):
                      """add or replace a callback to be called after the transaction closed
                      The transaction will be given as callback's first argument.
                      Category is a unique identifier to allow overwriting an old callback
                      with a newer callback.
                      """
                      self._postclosecallback[category] = callback
                  @active
                  def getpostclose(self, category):
                      """return a postclose callback added before, or None"""
                      return self._postclosecallback.get(category, None)
                  @active
                  def addabort(self, category, callback):
                      """add a callback to be called when the transaction is aborted.
                      The transaction will be given as the first argument to the callback.
                      Category is a unique identifier to allow overwriting an old callback
                      with a newer callback.
                      """
                      self._abortcallback[category] = callback
                  @active
                  def addvalidator(self, category, callback):
                      """adds a callback to be called when validating the transaction.
                      The transaction will be given as the first argument to the callback.
                      callback should raise exception if to abort transaction"""
                      self._validatecallback[category] = callback
                  @active
                  def close(self):
                      '''commit the transaction'''
                      if self._count == 1:
                          for category in sorted(self._validatecallback):
                              self._validatecallback[category](self)
                          self._validatecallback = None  # Help prevent cycles.
                          self._generatefiles(group=GEN_GROUP_PRE_FINALIZE)
                          while self._finalizecallback:
                              callbacks = self._finalizecallback
                              self._finalizecallback = {}
                              categories = sorted(callbacks)
                              for cat in categories:
                                  callbacks[cat](self)
                          # Prevent double usage and help clear cycles.
                          self._finalizecallback = None
                          self._generatefiles(group=GEN_GROUP_POST_FINALIZE)
                      self._count -= 1
                      if self._count != 0:
                          return
                      self._file.close()
                      self._backupsfile.close()
                      # cleanup temporary files
                      for l, f, b, c in self._backupentries:
                          if l not in self._vfsmap and c:
                              self._report(
                                  b"couldn't remove %s: unknown cache location %s\n" % (b, l)
                              )
                              continue
                          vfs = self._vfsmap[l]
                          if not f and b and vfs.exists(b):
                              try:
                                  vfs.unlink(b)
                              except (IOError, OSError, error.Abort) as inst:
                                  if not c:
                                      raise
                                  # Abort may be raise by read only opener
                                  self._report(
                                      b"couldn't remove %s: %s\n" % (vfs.join(b), inst)
                                  )
                      self._offsetmap = {}
                      self._newfiles = set()
                      self._writeundo()
                      if self._after:
                          self._after()
                          self._after = None  # Help prevent cycles.
                      if self._opener.isfile(self._backupjournal):
                          self._opener.unlink(self._backupjournal)
                      if self._opener.isfile(self._journal):
                          self._opener.unlink(self._journal)
                      for l, _f, b, c in self._backupentries:
                          if l not in self._vfsmap and c:
                              self._report(
                                  b"couldn't remove %s: unknown cache location"
                                  b"%s\n" % (b, l)
                              )
                              continue
                          vfs = self._vfsmap[l]
                          if b and vfs.exists(b):
                              try:
                                  vfs.unlink(b)
                              except (IOError, OSError, error.Abort) as inst:
                                  if not c:
                                      raise
                                  # Abort may be raise by read only opener
                                  self._report(
                                      b"couldn't remove %s: %s\n" % (vfs.join(b), inst)
                                  )
                      self._backupentries = []
                      self._journal = None
                      self._releasefn(self, True)  # notify success of closing transaction
                      self._releasefn = None  # Help prevent cycles.
                      # run post close action
                      categories = sorted(self._postclosecallback)
                      for cat in categories:
                          self._postclosecallback[cat](self)
                      # Prevent double usage and help clear cycles.
                      self._postclosecallback = None
                  @active
                  def abort(self):
                      """abort the transaction (generally called on error, or when the
                      transaction is not explicitly committed before going out of
                      scope)"""
                      self._abort()
                  @active
                  def add_journal(self, vfs_id, path):
                      self._journal_files.append((vfs_id, path))
                  def _writeundo(self):
                      """write transaction data for possible future undo call"""
                      if self._undoname is None:
                          return
                      cleanup_undo_files(
                          self._report,
                          self._vfsmap,
                          undo_prefix=self._undoname,
                      )
                      def undoname(fn: bytes) -> bytes:
                          base, name = os.path.split(fn)
                          assert name.startswith(self._journal)
                          new_name = name.replace(self._journal, self._undoname, 1)
                          return os.path.join(base, new_name)
                      undo_backup_path = b"%s.backupfiles" % self._undoname
                      undobackupfile = self._opener.open(undo_backup_path, b'w')
                      undobackupfile.write(b'%d\n' % version)
                      for l, f, b, c in self._backupentries:
                          if not f:  # temporary file
                              continue
                          if not b:
                              u = b''
                          else:
                              if l not in self._vfsmap and c:
                                  self._report(
                                      b"couldn't remove %s: unknown cache location"
                                      b"%s\n" % (b, l)
                                  )
                                  continue
                              vfs = self._vfsmap[l]
                              u = undoname(b)
                              util.copyfile(vfs.join(b), vfs.join(u), hardlink=True)
                          undobackupfile.write(b"%s\0%s\0%s\0%d\n" % (l, f, u, c))
                      undobackupfile.close()
                      for vfs, src in self._journal_files:
                          dest = undoname(src)
                          # if src and dest refer to a same file, vfs.rename is a no-op,
                          # leaving both src and dest on disk. delete dest to make sure
                          # the rename couldn't be such a no-op.
                          vfs.tryunlink(dest)
                          try:
                              vfs.rename(src, dest)
                          except FileNotFoundError:  # journal file does not yet exist
                              pass
                  def _abort(self):
                      entries = self.readjournal()
                      self._count = 0
                      self._usages = 0
                      self._file.close()
                      self._backupsfile.close()
                      quick = self._can_quick_abort(entries)
                      try:
                          if not quick:
                              self._report(_(b"transaction abort!\n"))
                          for cat in sorted(self._abortcallback):
                              self._abortcallback[cat](self)
                          # Prevent double usage and help clear cycles.
                          self._abortcallback = None
                          if quick:
                              self._do_quick_abort(entries)
                          else:
                              self._do_full_abort(entries)
                      finally:
                          self._journal = None
                          self._releasefn(self, False)  # notify failure of transaction
                          self._releasefn = None  # Help prevent cycles.
                  def _can_quick_abort(self, entries):
                      """False if any semantic content have been written on disk
                      True if nothing, except temporary files has been writen on disk."""
                      if entries:
                          return False
                      for e in self._backupentries:
                          if e[1]:
                              return False
                      return True
                  def _do_quick_abort(self, entries):
                      """(Silently) do a quick cleanup (see _can_quick_abort)"""
                      assert self._can_quick_abort(entries)
                      tmp_files = [e for e in self._backupentries if not e[1]]
                      for vfs_id, old_path, tmp_path, xxx in tmp_files:
                          vfs = self._vfsmap[vfs_id]
                          try:
                              vfs.unlink(tmp_path)
                          except FileNotFoundError:
                              pass
                      if self._backupjournal:
                          self._opener.unlink(self._backupjournal)
                      if self._journal:
                          self._opener.unlink(self._journal)
                  def _do_full_abort(self, entries):
                      """(Noisily) rollback all the change introduced by the transaction"""
                      try:
                          _playback(
                              self._journal,
                              self._report,
                              self._opener,
                              self._vfsmap,
                              entries,
                              self._backupentries,
                              unlink=True,
                              checkambigfiles=self._checkambigfiles,
                          )
                          self._report(_(b"rollback completed\n"))
                      except BaseException as exc:
                          self._report(_(b"rollback failed - please run hg recover\n"))
                          self._report(
                              _(b"(failure reason: %s)\n") % stringutil.forcebytestr(exc)
                          )
              BAD_VERSION_MSG = _(
                  b"journal was created by a different version of Mercurial\n"
              )
              def read_backup_files(report, fp):
                  """parse an (already open) backup file an return contained backup entries
                  entries are in the form: (location, file, backupfile, xxx)
                  :location:   the vfs identifier (vfsmap's key)
                  :file:       original file path (in the vfs)
                  :backupfile: path of the backup (in the vfs)
                  :cache:      a boolean currently always set to False
                  """
                  lines = fp.readlines()
                  backupentries = []
                  if lines:
                      ver = lines[0][:-1]
                      if ver != (b'%d' % version):
                          report(BAD_VERSION_MSG)
                      else:
                          for line in lines[1:]:
                              if line:
                                  # Shave off the trailing newline
                                  line = line[:-1]
                                  l, f, b, c = line.split(b'\0')
                                  backupentries.append((l, f, b, bool(c)))
                  return backupentries
              def rollback(
                  opener,
                  vfsmap,
                  file,
                  report,
                  checkambigfiles=None,
                  skip_journal_pattern=None,
              ):
                  """Rolls back the transaction contained in the given file
                  Reads the entries in the specified file, and the corresponding
                  '*.backupfiles' file, to recover from an incomplete transaction.
                  * `file`: a file containing a list of entries, specifying where
                  to truncate each file.  The file should contain a list of
                  file\0offset pairs, delimited by newlines. The corresponding
                  '*.backupfiles' file should contain a list of file\0backupfile
                  pairs, delimited by \0.
                  `checkambigfiles` is a set of (path, vfs-location) tuples,
                  which determine whether file stat ambiguity should be avoided at
                  restoring corresponded files.
                  """
                  entries = []
                  backupentries = []
                  with opener.open(file) as fp:
                      lines = fp.readlines()
                  for l in lines:
                      try:
                          f, o = l.split(b'\0')
                          entries.append((f, int(o)))
                      except ValueError:
                          report(
                              _(b"couldn't read journal entry %r!\n") % pycompat.bytestr(l)
                          )
                  backupjournal = b"%s.backupfiles" % file
                  if opener.exists(backupjournal):
                      with opener.open(backupjournal) as fp:
                          backupentries = read_backup_files(report, fp)
                  if skip_journal_pattern is not None:
                      keep = lambda x: not skip_journal_pattern.match(x[1])
                      backupentries = [x for x in backupentries if keep(x)]
                  _playback(
                      file,
                      report,
                      opener,
                      vfsmap,
                      entries,
                      backupentries,
                      checkambigfiles=checkambigfiles,
                  )

relnotes/6.5

0 +10 0

+             = Mercurial 6.5.2 =
+              * hgweb: encode WSGI environment using the ISO-8859-1 codec
+              * rhg: fix the bug where sparse config is interpreted as relglob instead of glob
+              * gpg: fix an UnboundLocalError whenever using --force
+              * transaction: fix __repr__() and make the default name bytes
+              * setup: make the error "Unable to find a working hg binary" more informative
+              * tests: avoid test environment affecting setup.py
+              * run-tests: detect HGWITHRUSTEXT value
              = Mercurial 6.5.1 =
               * A bunch of improvements to Python 3.12 compatibility
               * repoview: fix the filter created by `extrafilter`
               * Improve portability of the test suite
               * fncache: fix a bug that corrupts the fncache after transaction rollback
               * revlog: fix the naming scheme use by split temporary file
               * perf: fix perf::tags
              = Mercurial 6.5 =
              As usual, a lot of patches don't make it to this list since they're more internal.
              == New Features ==
               * Improved Python 3.12 compatiblity
               * configitems: enable changegroup3 by default (unless using infinitepush)
               * extras: expose 'retained_extras' for extensions to extend
               * stabletailgraph: implement stable-tail sort
               * stabletailgraph: naive version of leap computation
               * bundle: introduce a "v3" spec
               * clone-bundles: add a basic first version of automatic bundle generation
               * clone-bundles: garbage collect older bundle when generating new ones
               * clone-bundles: only regenerate the clone bundle when cached ration is low
               * clone-bundles: also control automation based on absolute number of revisions
               * clone-bundles: add a configuration to control auto-generation on changes
               * clone-bundles: introduce a command to refresh bundle
               * clone-bundles: add a command to clear all bundles
               * clone-bundles: add an option to generate bundles in the background
               * clonebundles: add support for inline (streaming) clonebundles
               * clonebundles: adds a auto-generate.serve-inline option
               * match: add `filepath:` pattern to match an exact filepath relative to the root
               * hgweb: add "children" into the JSON template for a changeset
               * hgweb: add support to explicitly access hidden changesets
               * pull: add --remote-hidden option and pass it through peer creation
               * hidden: add support for --remote-hidden to HTTP peer
               * hidden: support passing --hidden with `serve --stdio`
               * hidden: add support to explicitly access hidden changesets with SSH peers
               * perf: introduce a `perf::stream-locked-section` command
               * perf: add a function to find a stream version generator
               * perf: add support for stream-v3 during benchmark
               * perf: add a perf::stream-generate command
               * perf: add a perf::stream-consume
               * cli: make debugnodemap capable of inspecting an arbitrary nodemap
               * rust: configure MSRV in Clippy
               * rhg: make `rhg files` work if `ui.relative-files=true` is specified
               * rhg: support `rhg files` with `ui.relative-paths=false`
               * rhg: support `status --print0`
               * tree-manifest: allow `debugupgraderepo` to run on tree manifest repo
               * library: enable runpy invocation on mercurial package
               * library: incorporate demandimport into runpy invocation
               * exchange: allow passing no includes/excludes to `pull()`
              == New Experimental Features ==
               * stream-clone: add an experimental v3 version of the protocol
               * stream-clone: support streamv3 on the cli [hg bundle]
              == Bug Fixes ==
               * mail: add a missing argument to properly override starttls
               * bundle: include required phases when saving a bundle (issue6794)
               * outgoing: fix common-heads computation from `missingroots` argument
               * strip: do not include internal changeset in the strip backup
               * bundle: abort if the user request bundling of internal changesets
               * bundle: prevent implicit bundling of internal changeset
               * encoding: avoid quadratic time complexity when json-encoding non-UTF8 strings
               * sha1dc: Make sure SHA1DC_BIGENDIAN is set on Darwin/PowerPC
               * zstd: hack include order to ensure that our zstd.h is found
               * dirstate: better error messages when dirstate is corrupted
               * stream-clone: avoid opening a revlog in case we do not need it
               * treemanifest: make `updatecaches` update the nodemaps for all directories
               * rust-hg-core: move from `ouroboros` to `self_cell`
               * rust-dependencies: switch from `users` to `whoami`
               * dirstate-v2: actually fix the dirstate-v2 upgrade race
               * dirstate: avoid leaking disk space in `hg debugrebuilddirstate`
               * clonebundles: add warning if auto-generate is enabled without formats
               * win32mbcs: unbyteify some strings for py3 support
               * rust-revlog: fix incorrect results with NULL_NODE prefixes
               * rust-revlog: fix RevlogEntry.data() for NULL_REVISION
              == Backwards Compatibility Changes ==
               * infinitepush: aggressively deprecated infinite push
               * narrow: indicated the default of 'Yes' when confirming auto-remove-includes
              == Internal API Changes ==
               * Store walk was reworked to fix small race conditions in stream-clone and
                 greatly improve its API robustness and flexibility.
              == Miscellaneous ==
               * Typechecking support was improved in a lot of places
               * Removed more useless compat code for now unsupported Python versions
               * Sped up zstd usage in Rust contexts
               * revlog: add an exception hint when processing LFS flags without the extension
               * ui: keep the progress bar around when writing if stdout is not a tty
               * transaction: use a ".bck" extension for all backup file

setup.py

0 +26 -10

              #
              # This is the mercurial setup script.
              #
              # 'python setup.py install', or
              # 'python setup.py --help' for more options
              import os
              # Mercurial can't work on 3.6.0 or 3.6.1 due to a bug in % formatting
              # in bytestrings.
              supportedpy = ','.join(
                  [
                      '>=3.6.2',
                  ]
              )
              import sys, platform
              import sysconfig
              def sysstr(s):
                  return s.decode('latin-1')
              def eprint(*args, **kwargs):
                  kwargs['file'] = sys.stderr
                  print(*args, **kwargs)
              import ssl
              # ssl.HAS_TLSv1* are preferred to check support but they were added in Python
              # 3.7. Prior to CPython commit 6e8cda91d92da72800d891b2fc2073ecbc134d98
              # (backported to the 3.7 branch), ssl.PROTOCOL_TLSv1_1 / ssl.PROTOCOL_TLSv1_2
              # were defined only if compiled against a OpenSSL version with TLS 1.1 / 1.2
              # support. At the mentioned commit, they were unconditionally defined.
              _notset = object()
              has_tlsv1_1 = getattr(ssl, 'HAS_TLSv1_1', _notset)
              if has_tlsv1_1 is _notset:
                  has_tlsv1_1 = getattr(ssl, 'PROTOCOL_TLSv1_1', _notset) is not _notset
              has_tlsv1_2 = getattr(ssl, 'HAS_TLSv1_2', _notset)
              if has_tlsv1_2 is _notset:
                  has_tlsv1_2 = getattr(ssl, 'PROTOCOL_TLSv1_2', _notset) is not _notset
              if not (has_tlsv1_1 or has_tlsv1_2):
                  error = """
              The `ssl` module does not advertise support for TLS 1.1 or TLS 1.2.
              Please make sure that your Python installation was compiled against an OpenSSL
              version enabling these features (likely this requires the OpenSSL version to
              be at least 1.0.1).
              """
                  print(error, file=sys.stderr)
                  sys.exit(1)
              DYLIB_SUFFIX = sysconfig.get_config_vars()['EXT_SUFFIX']
              # Solaris Python packaging brain damage
              try:
                  import hashlib
                  sha = hashlib.sha1()
              except ImportError:
                  try:
                      import sha
                      sha.sha  # silence unused import warning
                  except ImportError:
                      raise SystemExit(
                          "Couldn't import standard hashlib (incomplete Python install)."
                      )
              try:
                  import zlib
                  zlib.compressobj  # silence unused import warning
              except ImportError:
                  raise SystemExit(
                      "Couldn't import standard zlib (incomplete Python install)."
                  )
              # The base IronPython distribution (as of 2.7.1) doesn't support bz2
              isironpython = False
              try:
                  isironpython = (
                      platform.python_implementation().lower().find("ironpython") != -1
                  )
              except AttributeError:
                  pass
              if isironpython:
                  sys.stderr.write("warning: IronPython detected (no bz2 support)\n")
              else:
                  try:
                      import bz2
                      bz2.BZ2Compressor  # silence unused import warning
                  except ImportError:
                      raise SystemExit(
                          "Couldn't import standard bz2 (incomplete Python install)."
                      )
              ispypy = "PyPy" in sys.version
              import ctypes
              import stat, subprocess, time
              import re
              import shutil
              import tempfile
              # We have issues with setuptools on some platforms and builders. Until
              # those are resolved, setuptools is opt-in except for platforms where
              # we don't have issues.
              issetuptools = os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ
              if issetuptools:
                  from setuptools import setup
              else:
                  try:
                      from distutils.core import setup
                  except ModuleNotFoundError:
                      from setuptools import setup
              from distutils.ccompiler import new_compiler
              from distutils.core import Command, Extension
              from distutils.dist import Distribution
              from distutils.command.build import build
              from distutils.command.build_ext import build_ext
              from distutils.command.build_py import build_py
              from distutils.command.build_scripts import build_scripts
              from distutils.command.install import install
              from distutils.command.install_lib import install_lib
              from distutils.command.install_scripts import install_scripts
              from distutils import log
              from distutils.spawn import spawn, find_executable
              from distutils import file_util
              from distutils.errors import (
                  CCompilerError,
                  DistutilsError,
                  DistutilsExecError,
              )
              from distutils.sysconfig import get_python_inc
              def write_if_changed(path, content):
                  """Write content to a file iff the content hasn't changed."""
                  if os.path.exists(path):
                      with open(path, 'rb') as fh:
                          current = fh.read()
                  else:
                      current = b''
                  if current != content:
                      with open(path, 'wb') as fh:
                          fh.write(content)
              scripts = ['hg']
              if os.name == 'nt':
                  # We remove hg.bat if we are able to build hg.exe.
                  scripts.append('contrib/win32/hg.bat')
              def cancompile(cc, code):
                  tmpdir = tempfile.mkdtemp(prefix='hg-install-')
                  devnull = oldstderr = None
                  try:
                      fname = os.path.join(tmpdir, 'testcomp.c')
                      f = open(fname, 'w')
                      f.write(code)
                      f.close()
                      # Redirect stderr to /dev/null to hide any error messages
                      # from the compiler.
                      # This will have to be changed if we ever have to check
                      # for a function on Windows.
                      devnull = open('/dev/null', 'w')
                      oldstderr = os.dup(sys.stderr.fileno())
                      os.dup2(devnull.fileno(), sys.stderr.fileno())
                      objects = cc.compile([fname], output_dir=tmpdir)
                      cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
                      return True
                  except Exception:
                      return False
                  finally:
                      if oldstderr is not None:
                          os.dup2(oldstderr, sys.stderr.fileno())
                      if devnull is not None:
                          devnull.close()
                      shutil.rmtree(tmpdir)
              # simplified version of distutils.ccompiler.CCompiler.has_function
              # that actually removes its temporary files.
              def hasfunction(cc, funcname):
                  code = 'int main(void) { %s(); }\n' % funcname
                  return cancompile(cc, code)
              def hasheader(cc, headername):
                  code = '#include <%s>\nint main(void) { return 0; }\n' % headername
                  return cancompile(cc, code)
              # py2exe needs to be installed to work
              try:
                  import py2exe
                  py2exe.patch_distutils()
                  py2exeloaded = True
                  # import py2exe's patched Distribution class
                  from distutils.core import Distribution
              except ImportError:
                  py2exeloaded = False
              def runcmd(cmd, env, cwd=None):
                  p = subprocess.Popen(
                      cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd
                  )
                  out, err = p.communicate()
                  return p.returncode, out, err
              class hgcommand:
                  def __init__(self, cmd, env):
                      self.cmd = cmd
                      self.env = env
                  def run(self, args):
                      cmd = self.cmd + args
                      returncode, out, err = runcmd(cmd, self.env)
                      err = filterhgerr(err)
                      if err:
                          print("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)
                          print(err, file=sys.stderr)
                      if returncode != 0:
                          return b''
                      return out
              def filterhgerr(err):
                  # If root is executing setup.py, but the repository is owned by
                  # another user (as in "sudo python setup.py install") we will get
                  # trust warnings since the .hg/hgrc file is untrusted. That is
                  # fine, we don't want to load it anyway.  Python may warn about
                  # a missing __init__.py in mercurial/locale, we also ignore that.
                  err = [
                      e
                      for e in err.splitlines()
                      if (
                          not e.startswith(b'not trusting file')
                          and not e.startswith(b'warning: Not importing')
                          and not e.startswith(b'obsolete feature not enabled')
                          and not e.startswith(b'*** failed to import extension')
                          and not e.startswith(b'devel-warn:')
                          and not (
                              e.startswith(b'(third party extension')
                              and e.endswith(b'or newer of Mercurial; disabling)')
                          )
                      )
                  ]
                  return b'\n'.join(b'  ' + e for e in err)
              def findhg():
                  """Try to figure out how we should invoke hg for examining the local
                  repository contents.
                  Returns an hgcommand object."""
                  # By default, prefer the "hg" command in the user's path.  This was
                  # presumably the hg command that the user used to create this repository.
                  #
                  # This repository may require extensions or other settings that would not
                  # be enabled by running the hg script directly from this local repository.
                  hgenv = os.environ.copy()
                  # Use HGPLAIN to disable hgrc settings that would change output formatting,
                  # and disable localization for the same reasons.
                  hgenv['HGPLAIN'] = '1'
                  hgenv['LANGUAGE'] = 'C'
                  hgcmd = ['hg']
                  # Run a simple "hg log" command just to see if using hg from the user's
                  # path works and can successfully interact with this repository.  Windows
                  # gives precedence to hg.exe in the current directory, so fall back to the
                  # python invocation of local hg, where pythonXY.dll can always be found.
                  check_cmd = ['log', '-r.', '-Ttest']
-                 if os.name != 'nt' or not os.path.exists("hg.exe"):
+                 attempts = []
+                 def attempt(cmd, env):
                      try:
                          retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
-                     except EnvironmentError:
-                         retcode = -1
-                     if retcode == 0 and not filterhgerr(err):
+                         res = (True, retcode, out, err)
+                         if retcode == 0 and not filterhgerr(err):
+                             return True
+                     except EnvironmentError as e:
+                         res = (False, e)
+                     attempts.append((cmd, res))
+                     return False
+                 if os.name != 'nt' or not os.path.exists("hg.exe"):
+                     if attempt(hgcmd + check_cmd, hgenv):
                          return hgcommand(hgcmd, hgenv)
                  # Fall back to trying the local hg installation.
                  hgenv = localhgenv()
                  hgcmd = [sys.executable, 'hg']
-                 try:
-                     retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
-                 except EnvironmentError:
-                     retcode = -1
-                 if retcode == 0 and not filterhgerr(err):
+                 if attempt(hgcmd + check_cmd, hgenv):
                      return hgcommand(hgcmd, hgenv)
                  eprint("/!\\")
                  eprint(r"/!\ Unable to find a working hg binary")
-                 eprint(r"/!\ Version cannot be extract from the repository")
+                 eprint(r"/!\ Version cannot be extracted from the repository")
                  eprint(r"/!\ Re-run the setup once a first version is built")
+                 eprint(r"/!\ Attempts:")
+                 for i, e in enumerate(attempts):
+                     eprint(r"/!\   attempt #%d:" % (i))
+                     eprint(r"/!\     cmd:        ", e[0])
+                     res = e[1]
+                     if res[0]:
+                         eprint(r"/!\     return code:", res[1])
+                         eprint("/!\\     std output:\n%s" % (res[2].decode()), end="")
+                         eprint("/!\\     std error:\n%s" % (res[3].decode()), end="")
+                     else:
+                         eprint(r"/!\     exception:  ", res[1])
                  return None
              def localhgenv():
                  """Get an environment dictionary to use for invoking or importing
                  mercurial from the local repository."""
                  # Execute hg out of this directory with a custom environment which takes
                  # care to not use any hgrc files and do no localization.
                  env = {
                      'HGMODULEPOLICY': 'py',
                      'HGRCPATH': '',
                      'LANGUAGE': 'C',
                      'PATH': '',
                  }  # make pypi modules that use os.environ['PATH'] happy
                  if 'LD_LIBRARY_PATH' in os.environ:
                      env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
                  if 'SystemRoot' in os.environ:
                      # SystemRoot is required by Windows to load various DLLs.  See:
                      # https://bugs.python.org/issue13524#msg148850
                      env['SystemRoot'] = os.environ['SystemRoot']
                  return env
              version = ''
              def _try_get_version():
                  hg = findhg()
                  if hg is None:
                      return ''
                  hgid = None
                  numerictags = []
                  cmd = ['log', '-r', '.', '--template', '{tags}\n']
                  pieces = sysstr(hg.run(cmd)).split()
                  numerictags = [t for t in pieces if t[0:1].isdigit()]
                  hgid = sysstr(hg.run(['id', '-i'])).strip()
                  if hgid.count('+') == 2:
                      hgid = hgid.replace("+", ".", 1)
                  if not hgid:
                      eprint("/!\\")
                      eprint(r"/!\ Unable to determine hg version from local repository")
                      eprint(r"/!\ Failed to retrieve current revision tags")
                      return ''
                  if numerictags:  # tag(s) found
                      version = numerictags[-1]
                      if hgid.endswith('+'):  # propagate the dirty status to the tag
                          version += '+'
                  else:  # no tag found on the checked out revision
                      ltagcmd = ['log', '--rev', 'wdir()', '--template', '{latesttag}']
                      ltag = sysstr(hg.run(ltagcmd))
                      if not ltag:
                          eprint("/!\\")
                          eprint(r"/!\ Unable to determine hg version from local repository")
                          eprint(
                              r"/!\ Failed to retrieve current revision distance to lated tag"
                          )
                          return ''
                      changessincecmd = [
                          'log',
                          '-T',
                          'x\n',
                          '-r',
                          "only(parents(),'%s')" % ltag,
                      ]
                      changessince = len(hg.run(changessincecmd).splitlines())
                      version = '%s+hg%s.%s' % (ltag, changessince, hgid)
                  if version.endswith('+'):
                      version = version[:-1] + 'local' + time.strftime('%Y%m%d')
                  return version
              if os.path.isdir('.hg'):
                  version = _try_get_version()
              elif os.path.exists('.hg_archival.txt'):
                  kw = dict(
                      [[t.strip() for t in l.split(':', 1)] for l in open('.hg_archival.txt')]
                  )
                  if 'tag' in kw:
                      version = kw['tag']
                  elif 'latesttag' in kw:
                      if 'changessincelatesttag' in kw:
                          version = (
                              '%(latesttag)s+hg%(changessincelatesttag)s.%(node).12s' % kw
                          )
                      else:
                          version = '%(latesttag)s+hg%(latesttagdistance)s.%(node).12s' % kw
                  else:
                      version = '0+hg' + kw.get('node', '')[:12]
              elif os.path.exists('mercurial/__version__.py'):
                  with open('mercurial/__version__.py') as f:
                      data = f.read()
                  version = re.search('version = b"(.*)"', data).group(1)
              if not version:
                  if os.environ.get("MERCURIAL_SETUP_MAKE_LOCAL") == "1":
                      version = "0.0+0"
                      eprint("/!\\")
                      eprint(r"/!\ Using '0.0+0' as the default version")
                      eprint(r"/!\ Re-run make local once that first version is built")
                      eprint("/!\\")
                  else:
                      eprint("/!\\")
                      eprint(r"/!\ Could not determine the Mercurial version")
                      eprint(r"/!\ You need to build a local version first")
                      eprint(r"/!\ Run `make local` and try again")
                      eprint("/!\\")
                      msg = "Run `make local` first to get a working local version"
                      raise SystemExit(msg)
              versionb = version
              if not isinstance(versionb, bytes):
                  versionb = versionb.encode('ascii')
              write_if_changed(
                  'mercurial/__version__.py',
                  b''.join(
                      [
                          b'# this file is autogenerated by setup.py\n'
                          b'version = b"%s"\n' % versionb,
                      ]
                  ),
              )
              class hgbuild(build):
                  # Insert hgbuildmo first so that files in mercurial/locale/ are found
                  # when build_py is run next.
                  sub_commands = [('build_mo', None)] + build.sub_commands
              class hgbuildmo(build):
                  description = "build translations (.mo files)"
                  def run(self):
                      if not find_executable('msgfmt'):
                          self.warn(
                              "could not find msgfmt executable, no translations "
                              "will be built"
                          )
                          return
                      podir = 'i18n'
                      if not os.path.isdir(podir):
                          self.warn("could not find %s/ directory" % podir)
                          return
                      join = os.path.join
                      for po in os.listdir(podir):
                          if not po.endswith('.po'):
                              continue
                          pofile = join(podir, po)
                          modir = join('locale', po[:-3], 'LC_MESSAGES')
                          mofile = join(modir, 'hg.mo')
                          mobuildfile = join('mercurial', mofile)
                          cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
                          if sys.platform != 'sunos5':
                              # msgfmt on Solaris does not know about -c
                              cmd.append('-c')
                          self.mkpath(join('mercurial', modir))
                          self.make_file([pofile], mobuildfile, spawn, (cmd,))
              class hgdist(Distribution):
                  pure = False
                  rust = False
                  no_rust = False
                  cffi = ispypy
                  global_options = Distribution.global_options + [
                      ('pure', None, "use pure (slow) Python code instead of C extensions"),
                      ('rust', None, "use Rust extensions additionally to C extensions"),
                      (
                          'no-rust',
                          None,
                          "do not use Rust extensions additionally to C extensions",
                      ),
                  ]
                  negative_opt = Distribution.negative_opt.copy()
                  boolean_options = ['pure', 'rust', 'no-rust']
                  negative_opt['no-rust'] = 'rust'
                  def _set_command_options(self, command_obj, option_dict=None):
                      # Not all distutils versions in the wild have boolean_options.
                      # This should be cleaned up when we're Python 3 only.
                      command_obj.boolean_options = (
                          getattr(command_obj, 'boolean_options', []) + self.boolean_options
                      )
                      return Distribution._set_command_options(
                          self, command_obj, option_dict=option_dict
                      )
                  def parse_command_line(self):
                      ret = Distribution.parse_command_line(self)
                      if not (self.rust or self.no_rust):
                          hgrustext = os.environ.get('HGWITHRUSTEXT')
                          # TODO record it for proper rebuild upon changes
                          # (see mercurial/__modulepolicy__.py)
                          if hgrustext != 'cpython' and hgrustext is not None:
                              if hgrustext:
                                  msg = 'unknown HGWITHRUSTEXT value: %s' % hgrustext
                                  print(msg, file=sys.stderr)
                              hgrustext = None
                          self.rust = hgrustext is not None
                          self.no_rust = not self.rust
                      return ret
                  def has_ext_modules(self):
                      # self.ext_modules is emptied in hgbuildpy.finalize_options which is
                      # too late for some cases
                      return not self.pure and Distribution.has_ext_modules(self)
              # This is ugly as a one-liner. So use a variable.
              buildextnegops = dict(getattr(build_ext, 'negative_options', {}))
              buildextnegops['no-zstd'] = 'zstd'
              buildextnegops['no-rust'] = 'rust'
              class hgbuildext(build_ext):
                  user_options = build_ext.user_options + [
                      ('zstd', None, 'compile zstd bindings [default]'),
                      ('no-zstd', None, 'do not compile zstd bindings'),
                      (
                          'rust',
                          None,
                          'compile Rust extensions if they are in use '
                          '(requires Cargo) [default]',
                      ),
                      ('no-rust', None, 'do not compile Rust extensions'),
                  ]
                  boolean_options = build_ext.boolean_options + ['zstd', 'rust']
                  negative_opt = buildextnegops
                  def initialize_options(self):
                      self.zstd = True
                      self.rust = True
                      return build_ext.initialize_options(self)
                  def finalize_options(self):
                      # Unless overridden by the end user, build extensions in parallel.
                      # Only influences behavior on Python 3.5+.
                      if getattr(self, 'parallel', None) is None:
                          self.parallel = True
                      return build_ext.finalize_options(self)
                  def build_extensions(self):
                      ruststandalones = [
                          e for e in self.extensions if isinstance(e, RustStandaloneExtension)
                      ]
                      self.extensions = [
                          e for e in self.extensions if e not in ruststandalones
                      ]
                      # Filter out zstd if disabled via argument.
                      if not self.zstd:
                          self.extensions = [
                              e for e in self.extensions if e.name != 'mercurial.zstd'
                          ]
                      # Build Rust standalone extensions if it'll be used
                      # and its build is not explicitly disabled (for external build
                      # as Linux distributions would do)
                      if self.distribution.rust and self.rust:
                          if not sys.platform.startswith('linux'):
                              self.warn(
                                  "rust extensions have only been tested on Linux "
                                  "and may not behave correctly on other platforms"
                              )
                          for rustext in ruststandalones:
                              rustext.build('' if self.inplace else self.build_lib)
                      return build_ext.build_extensions(self)
                  def build_extension(self, ext):
                      if (
                          self.distribution.rust
                          and self.rust
                          and isinstance(ext, RustExtension)
                      ):
                          ext.rustbuild()
                      try:
                          build_ext.build_extension(self, ext)
                      except CCompilerError:
                          if not getattr(ext, 'optional', False):
                              raise
                          log.warn(
                              "Failed to build optional extension '%s' (skipping)", ext.name
                          )
              class hgbuildscripts(build_scripts):
                  def run(self):
                      if os.name != 'nt' or self.distribution.pure:
                          return build_scripts.run(self)
                      exebuilt = False
                      try:
                          self.run_command('build_hgexe')
                          exebuilt = True
                      except (DistutilsError, CCompilerError):
                          log.warn('failed to build optional hg.exe')
                      if exebuilt:
                          # Copying hg.exe to the scripts build directory ensures it is
                          # installed by the install_scripts command.
                          hgexecommand = self.get_finalized_command('build_hgexe')
                          dest = os.path.join(self.build_dir, 'hg.exe')
                          self.mkpath(self.build_dir)
                          self.copy_file(hgexecommand.hgexepath, dest)
                          # Remove hg.bat because it is redundant with hg.exe.
                          self.scripts.remove('contrib/win32/hg.bat')
                      return build_scripts.run(self)
              class hgbuildpy(build_py):
                  def finalize_options(self):
                      build_py.finalize_options(self)
                      if self.distribution.pure:
                          self.distribution.ext_modules = []
                      elif self.distribution.cffi:
                          from mercurial.cffi import (
                              bdiffbuild,
                              mpatchbuild,
                          )
                          exts = [
                              mpatchbuild.ffi.distutils_extension(),
                              bdiffbuild.ffi.distutils_extension(),
                          ]
                          # cffi modules go here
                          if sys.platform == 'darwin':
                              from mercurial.cffi import osutilbuild
                              exts.append(osutilbuild.ffi.distutils_extension())
                          self.distribution.ext_modules = exts
                      else:
                          h = os.path.join(get_python_inc(), 'Python.h')
                          if not os.path.exists(h):
                              raise SystemExit(
                                  'Python headers are required to build '
                                  'Mercurial but weren\'t found in %s' % h
                              )
                  def run(self):
                      basepath = os.path.join(self.build_lib, 'mercurial')
                      self.mkpath(basepath)
                      rust = self.distribution.rust
                      if self.distribution.pure:
                          modulepolicy = 'py'
                      elif self.build_lib == '.':
                          # in-place build should run without rebuilding and Rust extensions
                          modulepolicy = 'rust+c-allow' if rust else 'allow'
                      else:
                          modulepolicy = 'rust+c' if rust else 'c'
                      content = b''.join(
                          [
                              b'# this file is autogenerated by setup.py\n',
                              b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
                          ]
                      )
                      write_if_changed(os.path.join(basepath, '__modulepolicy__.py'), content)
                      build_py.run(self)
              class buildhgextindex(Command):
                  description = 'generate prebuilt index of hgext (for frozen package)'
                  user_options = []
                  _indexfilename = 'hgext/__index__.py'
                  def initialize_options(self):
                      pass
                  def finalize_options(self):
                      pass
                  def run(self):
                      if os.path.exists(self._indexfilename):
                          with open(self._indexfilename, 'w') as f:
                              f.write('# empty\n')
                      # here no extension enabled, disabled() lists up everything
                      code = (
                          'import pprint; from mercurial import extensions; '
                          'ext = extensions.disabled();'
                          'ext.pop("__index__", None);'
                          'pprint.pprint(ext)'
                      )
                      returncode, out, err = runcmd(
                          [sys.executable, '-c', code], localhgenv()
                      )
                      if err or returncode != 0:
                          raise DistutilsExecError(err)
                      with open(self._indexfilename, 'wb') as f:
                          f.write(b'# this file is autogenerated by setup.py\n')
                          f.write(b'docs = ')
                          f.write(out)
              class buildhgexe(build_ext):
                  description = 'compile hg.exe from mercurial/exewrapper.c'
                  LONG_PATHS_MANIFEST = """\
              <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
              <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
                <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
                  <security>
                    <requestedPrivileges>
                      <requestedExecutionLevel
                        level="asInvoker"
                        uiAccess="false"
                      />
                    </requestedPrivileges>
                  </security>
                </trustInfo>
                <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
                  <application>
                    <!-- Windows Vista -->
                    <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
                    <!-- Windows 7 -->
                    <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
                    <!-- Windows 8 -->
                    <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
                    <!-- Windows 8.1 -->
                    <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
                    <!-- Windows 10 and Windows 11 -->
                    <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
                  </application>
                </compatibility>
                <application xmlns="urn:schemas-microsoft-com:asm.v3">
                  <windowsSettings
                      xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
                    <ws2:longPathAware>true</ws2:longPathAware>
                  </windowsSettings>
                </application>
                <dependency>
                  <dependentAssembly>
                    <assemblyIdentity type="win32"
                                      name="Microsoft.Windows.Common-Controls"
                                      version="6.0.0.0"
                                      processorArchitecture="*"
                                      publicKeyToken="6595b64144ccf1df"
                                      language="*" />
                  </dependentAssembly>
                </dependency>
              </assembly>
              """
                  def initialize_options(self):
                      build_ext.initialize_options(self)
                  def build_extensions(self):
                      if os.name != 'nt':
                          return
                      if isinstance(self.compiler, HackedMingw32CCompiler):
                          self.compiler.compiler_so = self.compiler.compiler  # no -mdll
                          self.compiler.dll_libraries = []  # no -lmsrvc90
                      pythonlib = None
                      dirname = os.path.dirname(self.get_ext_fullpath('dummy'))
                      self.hgtarget = os.path.join(dirname, 'hg')
                      if getattr(sys, 'dllhandle', None):
                          # Different Python installs can have different Python library
                          # names. e.g. the official CPython distribution uses pythonXY.dll
                          # and MinGW uses libpythonX.Y.dll.
                          _kernel32 = ctypes.windll.kernel32
                          _kernel32.GetModuleFileNameA.argtypes = [
                              ctypes.c_void_p,
                              ctypes.c_void_p,
                              ctypes.c_ulong,
                          ]
                          _kernel32.GetModuleFileNameA.restype = ctypes.c_ulong
                          size = 1000
                          buf = ctypes.create_string_buffer(size + 1)
                          filelen = _kernel32.GetModuleFileNameA(
                              sys.dllhandle, ctypes.byref(buf), size
                          )
                          if filelen > 0 and filelen != size:
                              dllbasename = os.path.basename(buf.value)
                              if not dllbasename.lower().endswith(b'.dll'):
                                  raise SystemExit(
                                      'Python DLL does not end with .dll: %s' % dllbasename
                                  )
                              pythonlib = dllbasename[:-4]
                              # Copy the pythonXY.dll next to the binary so that it runs
                              # without tampering with PATH.
                              dest = os.path.join(
                                  os.path.dirname(self.hgtarget),
                                  os.fsdecode(dllbasename),
                              )
                              if not os.path.exists(dest):
                                  shutil.copy(buf.value, dest)
                              # Also overwrite python3.dll so that hgext.git is usable.
                              # TODO: also handle the MSYS flavor
                              python_x = os.path.join(
                                  os.path.dirname(os.fsdecode(buf.value)),
                                  "python3.dll",
                              )
                              if os.path.exists(python_x):
                                  dest = os.path.join(
                                      os.path.dirname(self.hgtarget),
                                      os.path.basename(python_x),
                                  )
                                  shutil.copy(python_x, dest)
                      if not pythonlib:
                          log.warn(
                              'could not determine Python DLL filename; assuming pythonXY'
                          )
                          hv = sys.hexversion
                          pythonlib = b'python%d%d' % (hv >> 24, (hv >> 16) & 0xFF)
                      log.info('using %s as Python library name' % pythonlib)
                      with open('mercurial/hgpythonlib.h', 'wb') as f:
                          f.write(b'/* this file is autogenerated by setup.py */\n')
                          f.write(b'#define HGPYTHONLIB "%s"\n' % pythonlib)
                      objects = self.compiler.compile(
                          ['mercurial/exewrapper.c'],
                          output_dir=self.build_temp,
                          macros=[('_UNICODE', None), ('UNICODE', None)],
                      )
                      self.compiler.link_executable(
                          objects, self.hgtarget, libraries=[], output_dir=self.build_temp
                      )
                      self.addlongpathsmanifest()
                  def addlongpathsmanifest(self):
                      """Add manifest pieces so that hg.exe understands long paths
                      Why resource #1 should be used for .exe manifests? I don't know and
                      wasn't able to find an explanation for mortals. But it seems to work.
                      """
                      exefname = self.compiler.executable_filename(self.hgtarget)
                      fdauto, manfname = tempfile.mkstemp(suffix='.hg.exe.manifest')
                      os.close(fdauto)
                      with open(manfname, 'w', encoding="UTF-8") as f:
                          f.write(self.LONG_PATHS_MANIFEST)
                      log.info("long paths manifest is written to '%s'" % manfname)
                      outputresource = '-outputresource:%s;#1' % exefname
                      log.info("running mt.exe to update hg.exe's manifest in-place")
                      self.spawn(
                          [
                              self.compiler.mt,
                              '-nologo',
                              '-manifest',
                              manfname,
                              outputresource,
                          ]
                      )
                      log.info("done updating hg.exe's manifest")
                      os.remove(manfname)
                  @property
                  def hgexepath(self):
                      dir = os.path.dirname(self.get_ext_fullpath('dummy'))
                      return os.path.join(self.build_temp, dir, 'hg.exe')
              class hgbuilddoc(Command):
                  description = 'build documentation'
                  user_options = [
                      ('man', None, 'generate man pages'),
                      ('html', None, 'generate html pages'),
                  ]
                  def initialize_options(self):
                      self.man = None
                      self.html = None
                  def finalize_options(self):
                      # If --man or --html are set, only generate what we're told to.
                      # Otherwise generate everything.
                      have_subset = self.man is not None or self.html is not None
                      if have_subset:
                          self.man = True if self.man else False
                          self.html = True if self.html else False
                      else:
                          self.man = True
                          self.html = True
                  def run(self):
                      def normalizecrlf(p):
                          with open(p, 'rb') as fh:
                              orig = fh.read()
                          if b'\r\n' not in orig:
                              return
                          log.info('normalizing %s to LF line endings' % p)
                          with open(p, 'wb') as fh:
                              fh.write(orig.replace(b'\r\n', b'\n'))
                      def gentxt(root):
                          txt = 'doc/%s.txt' % root
                          log.info('generating %s' % txt)
                          res, out, err = runcmd(
                              [sys.executable, 'gendoc.py', root], os.environ, cwd='doc'
                          )
                          if res:
                              raise SystemExit(
                                  'error running gendoc.py: %s'
                                  % '\n'.join([sysstr(out), sysstr(err)])
                              )
                          with open(txt, 'wb') as fh:
                              fh.write(out)
                      def gengendoc(root):
                          gendoc = 'doc/%s.gendoc.txt' % root
                          log.info('generating %s' % gendoc)
                          res, out, err = runcmd(
                              [sys.executable, 'gendoc.py', '%s.gendoc' % root],
                              os.environ,
                              cwd='doc',
                          )
                          if res:
                              raise SystemExit(
                                  'error running gendoc: %s'
                                  % '\n'.join([sysstr(out), sysstr(err)])
                              )
                          with open(gendoc, 'wb') as fh:
                              fh.write(out)
                      def genman(root):
                          log.info('generating doc/%s' % root)
                          res, out, err = runcmd(
                              [
                                  sys.executable,
                                  'runrst',
                                  'hgmanpage',
                                  '--halt',
                                  'warning',
                                  '--strip-elements-with-class',
                                  'htmlonly',
                                  '%s.txt' % root,
                                  root,
                              ],
                              os.environ,
                              cwd='doc',
                          )
                          if res:
                              raise SystemExit(
                                  'error running runrst: %s'
                                  % '\n'.join([sysstr(out), sysstr(err)])
                              )
                          normalizecrlf('doc/%s' % root)
                      def genhtml(root):
                          log.info('generating doc/%s.html' % root)
                          res, out, err = runcmd(
                              [
                                  sys.executable,
                                  'runrst',
                                  'html',
                                  '--halt',
                                  'warning',
                                  '--link-stylesheet',
                                  '--stylesheet-path',
                                  'style.css',
                                  '%s.txt' % root,
                                  '%s.html' % root,
                              ],
                              os.environ,
                              cwd='doc',
                          )
                          if res:
                              raise SystemExit(
                                  'error running runrst: %s'
                                  % '\n'.join([sysstr(out), sysstr(err)])
                              )
                          normalizecrlf('doc/%s.html' % root)
                      # This logic is duplicated in doc/Makefile.
                      sources = {
                          f
                          for f in os.listdir('mercurial/helptext')
                          if re.search(r'[0-9]\.txt$', f)
                      }
                      # common.txt is a one-off.
                      gentxt('common')
                      for source in sorted(sources):
                          assert source[-4:] == '.txt'
                          root = source[:-4]
                          gentxt(root)
                          gengendoc(root)
                          if self.man:
                              genman(root)
                          if self.html:
                              genhtml(root)
              class hginstall(install):
                  user_options = install.user_options + [
                      (
                          'old-and-unmanageable',
                          None,
                          'noop, present for eggless setuptools compat',
                      ),
                      (
                          'single-version-externally-managed',
                          None,
                          'noop, present for eggless setuptools compat',
                      ),
                  ]
                  sub_commands = install.sub_commands + [
                      ('install_completion', lambda self: True)
                  ]
                  # Also helps setuptools not be sad while we refuse to create eggs.
                  single_version_externally_managed = True
                  def get_sub_commands(self):
                      # Screen out egg related commands to prevent egg generation.  But allow
                      # mercurial.egg-info generation, since that is part of modern
                      # packaging.
                      excl = {'bdist_egg'}
                      return filter(lambda x: x not in excl, install.get_sub_commands(self))
              class hginstalllib(install_lib):
                  """
                  This is a specialization of install_lib that replaces the copy_file used
                  there so that it supports setting the mode of files after copying them,
                  instead of just preserving the mode that the files originally had.  If your
                  system has a umask of something like 027, preserving the permissions when
                  copying will lead to a broken install.
                  Note that just passing keep_permissions=False to copy_file would be
                  insufficient, as it might still be applying a umask.
                  """
                  def run(self):
                      realcopyfile = file_util.copy_file
                      def copyfileandsetmode(*args, **kwargs):
                          src, dst = args[0], args[1]
                          dst, copied = realcopyfile(*args, **kwargs)
                          if copied:
                              st = os.stat(src)
                              # Persist executable bit (apply it to group and other if user
                              # has it)
                              if st[stat.ST_MODE] & stat.S_IXUSR:
                                  setmode = int('0755', 8)
                              else:
                                  setmode = int('0644', 8)
                              m = stat.S_IMODE(st[stat.ST_MODE])
                              m = (m & ~int('0777', 8)) | setmode
                              os.chmod(dst, m)
                      file_util.copy_file = copyfileandsetmode
                      try:
                          install_lib.run(self)
                      finally:
                          file_util.copy_file = realcopyfile
              class hginstallscripts(install_scripts):
                  """
                  This is a specialization of install_scripts that replaces the @LIBDIR@ with
                  the configured directory for modules. If possible, the path is made relative
                  to the directory for scripts.
                  """
                  def initialize_options(self):
                      install_scripts.initialize_options(self)
                      self.install_lib = None
                  def finalize_options(self):
                      install_scripts.finalize_options(self)
                      self.set_undefined_options('install', ('install_lib', 'install_lib'))
                  def run(self):
                      install_scripts.run(self)
                      # It only makes sense to replace @LIBDIR@ with the install path if
                      # the install path is known. For wheels, the logic below calculates
                      # the libdir to be "../..". This is because the internal layout of a
                      # wheel archive looks like:
                      #
                      #   mercurial-3.6.1.data/scripts/hg
                      #   mercurial/__init__.py
                      #
                      # When installing wheels, the subdirectories of the "<pkg>.data"
                      # directory are translated to system local paths and files therein
                      # are copied in place. The mercurial/* files are installed into the
                      # site-packages directory. However, the site-packages directory
                      # isn't known until wheel install time. This means we have no clue
                      # at wheel generation time what the installed site-packages directory
                      # will be. And, wheels don't appear to provide the ability to register
                      # custom code to run during wheel installation. This all means that
                      # we can't reliably set the libdir in wheels: the default behavior
                      # of looking in sys.path must do.
                      if (
                          os.path.splitdrive(self.install_dir)[0]
                          != os.path.splitdrive(self.install_lib)[0]
                      ):
                          # can't make relative paths from one drive to another, so use an
                          # absolute path instead
                          libdir = self.install_lib
                      else:
                          libdir = os.path.relpath(self.install_lib, self.install_dir)
                      for outfile in self.outfiles:
                          with open(outfile, 'rb') as fp:
                              data = fp.read()
                          # skip binary files
                          if b'\0' in data:
                              continue
                          # During local installs, the shebang will be rewritten to the final
                          # install path. During wheel packaging, the shebang has a special
                          # value.
                          if data.startswith(b'#!python'):
                              log.info(
                                  'not rewriting @LIBDIR@ in %s because install path '
                                  'not known' % outfile
                              )
                              continue
                          data = data.replace(b'@LIBDIR@', libdir.encode('unicode_escape'))
                          with open(outfile, 'wb') as fp:
                              fp.write(data)
              class hginstallcompletion(Command):
                  description = 'Install shell completion'
                  def initialize_options(self):
                      self.install_dir = None
                      self.outputs = []
                  def finalize_options(self):
                      self.set_undefined_options(
                          'install_data', ('install_dir', 'install_dir')
                      )
                  def get_outputs(self):
                      return self.outputs
                  def run(self):
                      for src, dir_path, dest in (
                          (
                              'bash_completion',
                              ('share', 'bash-completion', 'completions'),
                              'hg',
                          ),
                          ('zsh_completion', ('share', 'zsh', 'site-functions'), '_hg'),
                      ):
                          dir = os.path.join(self.install_dir, *dir_path)
                          self.mkpath(dir)
                          dest = os.path.join(dir, dest)
                          self.outputs.append(dest)
                          self.copy_file(os.path.join('contrib', src), dest)
              # virtualenv installs custom distutils/__init__.py and
              # distutils/distutils.cfg files which essentially proxy back to the
              # "real" distutils in the main Python install. The presence of this
              # directory causes py2exe to pick up the "hacked" distutils package
              # from the virtualenv and "import distutils" will fail from the py2exe
              # build because the "real" distutils files can't be located.
              #
              # We work around this by monkeypatching the py2exe code finding Python
              # modules to replace the found virtualenv distutils modules with the
              # original versions via filesystem scanning. This is a bit hacky. But
              # it allows us to use virtualenvs for py2exe packaging, which is more
              # deterministic and reproducible.
              #
              # It's worth noting that the common StackOverflow suggestions for this
              # problem involve copying the original distutils files into the
              # virtualenv or into the staging directory after setup() is invoked.
              # The former is very brittle and can easily break setup(). Our hacking
              # of the found modules routine has a similar result as copying the files
              # manually. But it makes fewer assumptions about how py2exe works and
              # is less brittle.
              # This only catches virtualenvs made with virtualenv (as opposed to
              # venv, which is likely what Python 3 uses).
              py2exehacked = py2exeloaded and getattr(sys, 'real_prefix', None) is not None
              if py2exehacked:
                  from distutils.command.py2exe import py2exe as buildpy2exe
                  from py2exe.mf import Module as py2exemodule
                  class hgbuildpy2exe(buildpy2exe):
                      def find_needed_modules(self, mf, files, modules):
                          res = buildpy2exe.find_needed_modules(self, mf, files, modules)
                          # Replace virtualenv's distutils modules with the real ones.
                          modules = {}
                          for k, v in res.modules.items():
                              if k != 'distutils' and not k.startswith('distutils.'):
                                  modules[k] = v
                          res.modules = modules
                          import opcode
                          distutilsreal = os.path.join(
                              os.path.dirname(opcode.__file__), 'distutils'
                          )
                          for root, dirs, files in os.walk(distutilsreal):
                              for f in sorted(files):
                                  if not f.endswith('.py'):
                                      continue
                                  full = os.path.join(root, f)
                                  parents = ['distutils']
                                  if root != distutilsreal:
                                      rel = os.path.relpath(root, distutilsreal)
                                      parents.extend(p for p in rel.split(os.sep))
                                  modname = '%s.%s' % ('.'.join(parents), f[:-3])
                                  if modname.startswith('distutils.tests.'):
                                      continue
                                  if modname.endswith('.__init__'):
                                      modname = modname[: -len('.__init__')]
                                      path = os.path.dirname(full)
                                  else:
                                      path = None
                                  res.modules[modname] = py2exemodule(
                                      modname, full, path=path
                                  )
                          if 'distutils' not in res.modules:
                              raise SystemExit('could not find distutils modules')
                          return res
              cmdclass = {
                  'build': hgbuild,
                  'build_doc': hgbuilddoc,
                  'build_mo': hgbuildmo,
                  'build_ext': hgbuildext,
                  'build_py': hgbuildpy,
                  'build_scripts': hgbuildscripts,
                  'build_hgextindex': buildhgextindex,
                  'install': hginstall,
                  'install_completion': hginstallcompletion,
                  'install_lib': hginstalllib,
                  'install_scripts': hginstallscripts,
                  'build_hgexe': buildhgexe,
              }
              if py2exehacked:
                  cmdclass['py2exe'] = hgbuildpy2exe
              packages = [
                  'mercurial',
                  'mercurial.cext',
                  'mercurial.cffi',
                  'mercurial.defaultrc',
                  'mercurial.dirstateutils',
                  'mercurial.helptext',
                  'mercurial.helptext.internals',
                  'mercurial.hgweb',
                  'mercurial.interfaces',
                  'mercurial.pure',
                  'mercurial.stabletailgraph',
                  'mercurial.templates',
                  'mercurial.thirdparty',
                  'mercurial.thirdparty.attr',
                  'mercurial.thirdparty.tomli',
                  'mercurial.thirdparty.zope',
                  'mercurial.thirdparty.zope.interface',
                  'mercurial.upgrade_utils',
                  'mercurial.utils',
                  'mercurial.revlogutils',
                  'mercurial.testing',
                  'hgext',
                  'hgext.convert',
                  'hgext.fsmonitor',
                  'hgext.fastannotate',
                  'hgext.fsmonitor.pywatchman',
                  'hgext.git',
                  'hgext.highlight',
                  'hgext.hooklib',
                  'hgext.largefiles',
                  'hgext.lfs',
                  'hgext.narrow',
                  'hgext.remotefilelog',
                  'hgext.zeroconf',
                  'hgext3rd',
                  'hgdemandimport',
              ]
              for name in os.listdir(os.path.join('mercurial', 'templates')):
                  if name != '__pycache__' and os.path.isdir(
                      os.path.join('mercurial', 'templates', name)
                  ):
                      packages.append('mercurial.templates.%s' % name)
              if 'HG_PY2EXE_EXTRA_INSTALL_PACKAGES' in os.environ:
                  # py2exe can't cope with namespace packages very well, so we have to
                  # install any hgext3rd.* extensions that we want in the final py2exe
                  # image here. This is gross, but you gotta do what you gotta do.
                  packages.extend(os.environ['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'].split(' '))
              common_depends = [
                  'mercurial/bitmanipulation.h',
                  'mercurial/compat.h',
                  'mercurial/cext/util.h',
              ]
              common_include_dirs = ['mercurial']
              common_cflags = []
              # MSVC 2008 still needs declarations at the top of the scope, but Python 3.9
              # makes declarations not at the top of a scope in the headers.
              if os.name != 'nt' and sys.version_info[1] < 9:
                  common_cflags = ['-Werror=declaration-after-statement']
              osutil_cflags = []
              osutil_ldflags = []
              # platform specific macros
              for plat, func in [('bsd', 'setproctitle')]:
                  if re.search(plat, sys.platform) and hasfunction(new_compiler(), func):
                      osutil_cflags.append('-DHAVE_%s' % func.upper())
              for plat, macro, code in [
                  (
                      'bsd|darwin',
                      'BSD_STATFS',
                      '''
                   #include <sys/param.h>
                   #include <sys/mount.h>
                   int main() { struct statfs s; return sizeof(s.f_fstypename); }
                   ''',
                  ),
                  (
                      'linux',
                      'LINUX_STATFS',
                      '''
                   #include <linux/magic.h>
                   #include <sys/vfs.h>
                   int main() { struct statfs s; return sizeof(s.f_type); }
                   ''',
                  ),
              ]:
                  if re.search(plat, sys.platform) and cancompile(new_compiler(), code):
                      osutil_cflags.append('-DHAVE_%s' % macro)
              if sys.platform == 'darwin':
                  osutil_ldflags += ['-framework', 'ApplicationServices']
              if sys.platform == 'sunos5':
                  osutil_ldflags += ['-lsocket']
              xdiff_srcs = [
                  'mercurial/thirdparty/xdiff/xdiffi.c',
                  'mercurial/thirdparty/xdiff/xprepare.c',
                  'mercurial/thirdparty/xdiff/xutils.c',
              ]
              xdiff_headers = [
                  'mercurial/thirdparty/xdiff/xdiff.h',
                  'mercurial/thirdparty/xdiff/xdiffi.h',
                  'mercurial/thirdparty/xdiff/xinclude.h',
                  'mercurial/thirdparty/xdiff/xmacros.h',
                  'mercurial/thirdparty/xdiff/xprepare.h',
                  'mercurial/thirdparty/xdiff/xtypes.h',
                  'mercurial/thirdparty/xdiff/xutils.h',
              ]
              class RustCompilationError(CCompilerError):
                  """Exception class for Rust compilation errors."""
              class RustExtension(Extension):
                  """Base classes for concrete Rust Extension classes."""
                  rusttargetdir = os.path.join('rust', 'target', 'release')
                  def __init__(self, mpath, sources, rustlibname, subcrate, **kw):
                      Extension.__init__(self, mpath, sources, **kw)
                      srcdir = self.rustsrcdir = os.path.join('rust', subcrate)
                      # adding Rust source and control files to depends so that the extension
                      # gets rebuilt if they've changed
                      self.depends.append(os.path.join(srcdir, 'Cargo.toml'))
                      cargo_lock = os.path.join(srcdir, 'Cargo.lock')
                      if os.path.exists(cargo_lock):
                          self.depends.append(cargo_lock)
                      for dirpath, subdir, fnames in os.walk(os.path.join(srcdir, 'src')):
                          self.depends.extend(
                              os.path.join(dirpath, fname)
                              for fname in fnames
                              if os.path.splitext(fname)[1] == '.rs'
                          )
                  @staticmethod
                  def rustdylibsuffix():
                      """Return the suffix for shared libraries produced by rustc.
                      See also: https://doc.rust-lang.org/reference/linkage.html
                      """
                      if sys.platform == 'darwin':
                          return '.dylib'
                      elif os.name == 'nt':
                          return '.dll'
                      else:
                          return '.so'
                  def rustbuild(self):
                      env = os.environ.copy()
                      if 'HGTEST_RESTOREENV' in env:
                          # Mercurial tests change HOME to a temporary directory,
                          # but, if installed with rustup, the Rust toolchain needs
                          # HOME to be correct (otherwise the 'no default toolchain'
                          # error message is issued and the build fails).
                          # This happens currently with test-hghave.t, which does
                          # invoke this build.
                          # Unix only fix (os.path.expanduser not really reliable if
                          # HOME is shadowed like this)
                          import pwd
                          env['HOME'] = pwd.getpwuid(os.getuid()).pw_dir
                      cargocmd = ['cargo', 'rustc', '--release']
                      rust_features = env.get("HG_RUST_FEATURES")
                      if rust_features:
                          cargocmd.extend(('--features', rust_features))
                      cargocmd.append('--')
                      if sys.platform == 'darwin':
                          cargocmd.extend(
                              ("-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup")
                          )
                      try:
                          subprocess.check_call(cargocmd, env=env, cwd=self.rustsrcdir)
                      except FileNotFoundError:
                          raise RustCompilationError("Cargo not found")
                      except PermissionError:
                          raise RustCompilationError(
                              "Cargo found, but permission to execute it is denied"
                          )
                      except subprocess.CalledProcessError:
                          raise RustCompilationError(
                              "Cargo failed. Working directory: %r, "
                              "command: %r, environment: %r"
                              % (self.rustsrcdir, cargocmd, env)
                          )
              class RustStandaloneExtension(RustExtension):
                  def __init__(self, pydottedname, rustcrate, dylibname, **kw):
                      RustExtension.__init__(
                          self, pydottedname, [], dylibname, rustcrate, **kw
                      )
                      self.dylibname = dylibname
                  def build(self, target_dir):
                      self.rustbuild()
                      target = [target_dir]
                      target.extend(self.name.split('.'))
                      target[-1] += DYLIB_SUFFIX
                      target = os.path.join(*target)
                      os.makedirs(os.path.dirname(target), exist_ok=True)
                      shutil.copy2(
                          os.path.join(
                              self.rusttargetdir, self.dylibname + self.rustdylibsuffix()
                          ),
                          target,
                      )
              extmodules = [
                  Extension(
                      'mercurial.cext.base85',
                      ['mercurial/cext/base85.c'],
                      include_dirs=common_include_dirs,
                      extra_compile_args=common_cflags,
                      depends=common_depends,
                  ),
                  Extension(
                      'mercurial.cext.bdiff',
                      ['mercurial/bdiff.c', 'mercurial/cext/bdiff.c'] + xdiff_srcs,
                      include_dirs=common_include_dirs,
                      extra_compile_args=common_cflags,
                      depends=common_depends + ['mercurial/bdiff.h'] + xdiff_headers,
                  ),
                  Extension(
                      'mercurial.cext.mpatch',
                      ['mercurial/mpatch.c', 'mercurial/cext/mpatch.c'],
                      include_dirs=common_include_dirs,
                      extra_compile_args=common_cflags,
                      depends=common_depends,
                  ),
                  Extension(
                      'mercurial.cext.parsers',
                      [
                          'mercurial/cext/charencode.c',
                          'mercurial/cext/dirs.c',
                          'mercurial/cext/manifest.c',
                          'mercurial/cext/parsers.c',
                          'mercurial/cext/pathencode.c',
                          'mercurial/cext/revlog.c',
                      ],
                      include_dirs=common_include_dirs,
                      extra_compile_args=common_cflags,
                      depends=common_depends
                      + [
                          'mercurial/cext/charencode.h',
                          'mercurial/cext/revlog.h',
                      ],
                  ),
                  Extension(
                      'mercurial.cext.osutil',
                      ['mercurial/cext/osutil.c'],
                      include_dirs=common_include_dirs,
                      extra_compile_args=common_cflags + osutil_cflags,
                      extra_link_args=osutil_ldflags,
                      depends=common_depends,
                  ),
                  Extension(
                      'mercurial.thirdparty.zope.interface._zope_interface_coptimizations',
                      [
                          'mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c',
                      ],
                      extra_compile_args=common_cflags,
                  ),
                  Extension(
                      'mercurial.thirdparty.sha1dc',
                      [
                          'mercurial/thirdparty/sha1dc/cext.c',
                          'mercurial/thirdparty/sha1dc/lib/sha1.c',
                          'mercurial/thirdparty/sha1dc/lib/ubc_check.c',
                      ],
                      extra_compile_args=common_cflags,
                  ),
                  Extension(
                      'hgext.fsmonitor.pywatchman.bser',
                      ['hgext/fsmonitor/pywatchman/bser.c'],
                      extra_compile_args=common_cflags,
                  ),
                  RustStandaloneExtension(
                      'mercurial.rustext',
                      'hg-cpython',
                      'librusthg',
                  ),
              ]
              sys.path.insert(0, 'contrib/python-zstandard')
              import setup_zstd
              zstd = setup_zstd.get_c_extension(
                  name='mercurial.zstd', root=os.path.abspath(os.path.dirname(__file__))
              )
              zstd.extra_compile_args += common_cflags
              extmodules.append(zstd)
              try:
                  from distutils import cygwinccompiler
                  # the -mno-cygwin option has been deprecated for years
                  mingw32compilerclass = cygwinccompiler.Mingw32CCompiler
                  class HackedMingw32CCompiler(cygwinccompiler.Mingw32CCompiler):
                      def __init__(self, *args, **kwargs):
                          mingw32compilerclass.__init__(self, *args, **kwargs)
                          for i in 'compiler compiler_so linker_exe linker_so'.split():
                              try:
                                  getattr(self, i).remove('-mno-cygwin')
                              except ValueError:
                                  pass
                  cygwinccompiler.Mingw32CCompiler = HackedMingw32CCompiler
              except ImportError:
                  # the cygwinccompiler package is not available on some Python
                  # distributions like the ones from the optware project for Synology
                  # DiskStation boxes
                  class HackedMingw32CCompiler:
                      pass
              if os.name == 'nt':
                  # Allow compiler/linker flags to be added to Visual Studio builds.  Passing
                  # extra_link_args to distutils.extensions.Extension() doesn't have any
                  # effect.
                  from distutils import msvccompiler
                  msvccompilerclass = msvccompiler.MSVCCompiler
                  class HackedMSVCCompiler(msvccompiler.MSVCCompiler):
                      def initialize(self):
                          msvccompilerclass.initialize(self)
                          # "warning LNK4197: export 'func' specified multiple times"
                          self.ldflags_shared.append('/ignore:4197')
                          self.ldflags_shared_debug.append('/ignore:4197')
                  msvccompiler.MSVCCompiler = HackedMSVCCompiler
              packagedata = {
                  'mercurial': [
                      'configitems.toml',
                      'locale/*/LC_MESSAGES/hg.mo',
                      'dummycert.pem',
                  ],
                  'mercurial.defaultrc': [
                      '*.rc',
                  ],
                  'mercurial.helptext': [
                      '*.txt',
                  ],
                  'mercurial.helptext.internals': [
                      '*.txt',
                  ],
                  'mercurial.thirdparty.attr': [
                      '*.pyi',
                      'py.typed',
                  ],
              }
              def ordinarypath(p):
                  return p and p[0] != '.' and p[-1] != '~'
              for root in ('templates',):
                  for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
                      packagename = curdir.replace(os.sep, '.')
                      packagedata[packagename] = list(filter(ordinarypath, files))
              datafiles = []
              # distutils expects version to be str/unicode. Converting it to
              # unicode on Python 2 still works because it won't contain any
              # non-ascii bytes and will be implicitly converted back to bytes
              # when operated on.
              assert isinstance(version, str)
              setupversion = version
              extra = {}
              py2exepackages = [
                  'hgdemandimport',
                  'hgext3rd',
                  'hgext',
                  'email',
                  # implicitly imported per module policy
                  # (cffi wouldn't be used as a frozen exe)
                  'mercurial.cext',
                  #'mercurial.cffi',
                  'mercurial.pure',
              ]
              py2exe_includes = []
              py2exeexcludes = []
              py2exedllexcludes = ['crypt32.dll']
              if issetuptools:
                  extra['python_requires'] = supportedpy
              if py2exeloaded:
                  extra['console'] = [
                      {
                          'script': 'hg',
                          'copyright': 'Copyright (C) 2005-2023 Olivia Mackall and others',
                          'product_version': version,
                      }
                  ]
                  # Sub command of 'build' because 'py2exe' does not handle sub_commands.
                  # Need to override hgbuild because it has a private copy of
                  # build.sub_commands.
                  hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
                  # put dlls in sub directory so that they won't pollute PATH
                  extra['zipfile'] = 'lib/library.zip'
                  # We allow some configuration to be supplemented via environment
                  # variables. This is better than setup.cfg files because it allows
                  # supplementing configs instead of replacing them.
                  extrapackages = os.environ.get('HG_PY2EXE_EXTRA_PACKAGES')
                  if extrapackages:
                      py2exepackages.extend(extrapackages.split(' '))
                  extra_includes = os.environ.get('HG_PY2EXE_EXTRA_INCLUDES')
                  if extra_includes:
                      py2exe_includes.extend(extra_includes.split(' '))
                  excludes = os.environ.get('HG_PY2EXE_EXTRA_EXCLUDES')
                  if excludes:
                      py2exeexcludes.extend(excludes.split(' '))
                  dllexcludes = os.environ.get('HG_PY2EXE_EXTRA_DLL_EXCLUDES')
                  if dllexcludes:
                      py2exedllexcludes.extend(dllexcludes.split(' '))
              if os.environ.get('PYOXIDIZER'):
                  hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
              if os.name == 'nt':
                  # Windows binary file versions for exe/dll files must have the
                  # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
                  setupversion = setupversion.split(r'+', 1)[0]
              setup(
                  name='mercurial',
                  version=setupversion,
                  author='Olivia Mackall and many others',
                  author_email='mercurial@mercurial-scm.org',
                  url='https://mercurial-scm.org/',
                  download_url='https://mercurial-scm.org/release/',
                  description=(
                      'Fast scalable distributed SCM (revision control, version '
                      'control) system'
                  ),
                  long_description=(
                      'Mercurial is a distributed SCM tool written in Python.'
                      ' It is used by a number of large projects that require'
                      ' fast, reliable distributed revision control, such as '
                      'Mozilla.'
                  ),
                  license='GNU GPLv2 or any later version',
                  classifiers=[
                      'Development Status :: 6 - Mature',
                      'Environment :: Console',
                      'Intended Audience :: Developers',
                      'Intended Audience :: System Administrators',
                      'License :: OSI Approved :: GNU General Public License (GPL)',
                      'Natural Language :: Danish',
                      'Natural Language :: English',
                      'Natural Language :: German',
                      'Natural Language :: Italian',
                      'Natural Language :: Japanese',
                      'Natural Language :: Portuguese (Brazilian)',
                      'Operating System :: Microsoft :: Windows',
                      'Operating System :: OS Independent',
                      'Operating System :: POSIX',
                      'Programming Language :: C',
                      'Programming Language :: Python',
                      'Topic :: Software Development :: Version Control',
                  ],
                  scripts=scripts,
                  packages=packages,
                  ext_modules=extmodules,
                  data_files=datafiles,
                  package_data=packagedata,
                  cmdclass=cmdclass,
                  distclass=hgdist,
                  options={
                      'py2exe': {
                          'bundle_files': 3,
                          'dll_excludes': py2exedllexcludes,
                          'includes': py2exe_includes,
                          'excludes': py2exeexcludes,
                          'packages': py2exepackages,
                      },
                      'bdist_mpkg': {
                          'zipdist': False,
                          'license': 'COPYING',
                          'readme': 'contrib/packaging/macosx/Readme.html',
                          'welcome': 'contrib/packaging/macosx/Welcome.html',
                      },
                  },
                  **extra
              )

tests/run-tests.py

0 +2 -1

              #!/usr/bin/env python3
              #
              # run-tests.py - Run a set of tests on Mercurial
              #
              # Copyright 2006 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.
              # Modifying this script is tricky because it has many modes:
              #   - serial (default) vs parallel (-jN, N > 1)
              #   - no coverage (default) vs coverage (-c, -C, -s)
              #   - temp install (default) vs specific hg script (--with-hg, --local)
              #   - tests are a mix of shell scripts and Python scripts
              #
              # If you change this script, it is recommended that you ensure you
              # haven't broken it by running it in various modes with a representative
              # sample of test scripts.  For example:
              #
              #  1) serial, no coverage, temp install:
              #      ./run-tests.py test-s*
              #  2) serial, no coverage, local hg:
              #      ./run-tests.py --local test-s*
              #  3) serial, coverage, temp install:
              #      ./run-tests.py -c test-s*
              #  4) serial, coverage, local hg:
              #      ./run-tests.py -c --local test-s*      # unsupported
              #  5) parallel, no coverage, temp install:
              #      ./run-tests.py -j2 test-s*
              #  6) parallel, no coverage, local hg:
              #      ./run-tests.py -j2 --local test-s*
              #  7) parallel, coverage, temp install:
              #      ./run-tests.py -j2 -c test-s*          # currently broken
              #  8) parallel, coverage, local install:
              #      ./run-tests.py -j2 -c --local test-s*  # unsupported (and broken)
              #  9) parallel, custom tmp dir:
              #      ./run-tests.py -j2 --tmpdir /tmp/myhgtests
              #  10) parallel, pure, tests that call run-tests:
              #      ./run-tests.py --pure `grep -l run-tests.py *.t`
              #
              # (You could use any subset of the tests: test-s* happens to match
              # enough that it's worth doing parallel runs, few enough that it
              # completes fairly quickly, includes both shell and Python scripts, and
              # includes some scripts that run daemon processes.)
              import argparse
              import collections
              import contextlib
              import difflib
              import errno
              import functools
              import json
              import multiprocessing
              import os
              import platform
              import queue
              import random
              import re
              import shlex
              import shutil
              import signal
              import socket
              import subprocess
              import sys
              import sysconfig
              import tempfile
              import threading
              import time
              import unittest
              import uuid
              import xml.dom.minidom as minidom
              if sys.version_info < (3, 5, 0):
                  print(
                      '%s is only supported on Python 3.5+, not %s'
                      % (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3]))
                  )
                  sys.exit(70)  # EX_SOFTWARE from `man 3 sysexit`
              MACOS = sys.platform == 'darwin'
              WINDOWS = os.name == r'nt'
              shellquote = shlex.quote
              processlock = threading.Lock()
              pygmentspresent = False
              try:  # is pygments installed
                  import pygments
                  import pygments.lexers as lexers
                  import pygments.lexer as lexer
                  import pygments.formatters as formatters
                  import pygments.token as token
                  import pygments.style as style
                  if WINDOWS:
                      hgpath = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
                      sys.path.append(hgpath)
                      try:
                          from mercurial import win32  # pytype: disable=import-error
                          # Don't check the result code because it fails on heptapod, but
                          # something is able to convert to color anyway.
                          win32.enablevtmode()
                      finally:
                          sys.path = sys.path[:-1]
                  pygmentspresent = True
                  difflexer = lexers.DiffLexer()
                  terminal256formatter = formatters.Terminal256Formatter()
              except ImportError:
                  pass
              if pygmentspresent:
                  class TestRunnerStyle(style.Style):
                      default_style = ""
                      skipped = token.string_to_tokentype("Token.Generic.Skipped")
                      failed = token.string_to_tokentype("Token.Generic.Failed")
                      skippedname = token.string_to_tokentype("Token.Generic.SName")
                      failedname = token.string_to_tokentype("Token.Generic.FName")
                      styles = {
                          skipped: '#e5e5e5',
                          skippedname: '#00ffff',
                          failed: '#7f0000',
                          failedname: '#ff0000',
                      }
                  class TestRunnerLexer(lexer.RegexLexer):
                      testpattern = r'[\w-]+\.(t|py)(#[a-zA-Z0-9_\-\.]+)?'
                      tokens = {
                          'root': [
                              (r'^Skipped', token.Generic.Skipped, 'skipped'),
                              (r'^Failed ', token.Generic.Failed, 'failed'),
                              (r'^ERROR: ', token.Generic.Failed, 'failed'),
                          ],
                          'skipped': [
                              (testpattern, token.Generic.SName),
                              (r':.*', token.Generic.Skipped),
                          ],
                          'failed': [
                              (testpattern, token.Generic.FName),
                              (r'(:| ).*', token.Generic.Failed),
                          ],
                      }
                  runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle)
                  runnerlexer = TestRunnerLexer()
              origenviron = os.environ.copy()
              def _sys2bytes(p):
                  if p is None:
                      return p
                  return p.encode('utf-8')
              def _bytes2sys(p):
                  if p is None:
                      return p
                  return p.decode('utf-8')
+             original_env = os.environ.copy()
              osenvironb = getattr(os, 'environb', None)
              if osenvironb is None:
                  # Windows lacks os.environb, for instance.  A proxy over the real thing
                  # instead of a copy allows the environment to be updated via bytes on
                  # all platforms.
                  class environbytes:
                      def __init__(self, strenv):
                          self.__len__ = strenv.__len__
                          self.clear = strenv.clear
                          self._strenv = strenv
                      def __getitem__(self, k):
                          v = self._strenv.__getitem__(_bytes2sys(k))
                          return _sys2bytes(v)
                      def __setitem__(self, k, v):
                          self._strenv.__setitem__(_bytes2sys(k), _bytes2sys(v))
                      def __delitem__(self, k):
                          self._strenv.__delitem__(_bytes2sys(k))
                      def __contains__(self, k):
                          return self._strenv.__contains__(_bytes2sys(k))
                      def __iter__(self):
                          return iter([_sys2bytes(k) for k in iter(self._strenv)])
                      def get(self, k, default=None):
                          v = self._strenv.get(_bytes2sys(k), _bytes2sys(default))
                          return _sys2bytes(v)
                      def pop(self, k, default=None):
                          v = self._strenv.pop(_bytes2sys(k), _bytes2sys(default))
                          return _sys2bytes(v)
                  osenvironb = environbytes(os.environ)
              getcwdb = getattr(os, 'getcwdb')
              if not getcwdb or WINDOWS:
                  getcwdb = lambda: _sys2bytes(os.getcwd())
              if WINDOWS:
                  _getcwdb = getcwdb
                  def getcwdb():
                      cwd = _getcwdb()
                      if re.match(b'^[a-z]:', cwd):
                          # os.getcwd() is inconsistent on the capitalization of the drive
                          # letter, so adjust it. see https://bugs.python.org/issue40368
                          cwd = cwd[0:1].upper() + cwd[1:]
                      return cwd
              # For Windows support
              wifexited = getattr(os, "WIFEXITED", lambda x: False)
              # Whether to use IPv6
              def checksocketfamily(name, port=20058):
                  """return true if we can listen on localhost using family=name
                  name should be either 'AF_INET', or 'AF_INET6'.
                  port being used is okay - EADDRINUSE is considered as successful.
                  """
                  family = getattr(socket, name, None)
                  if family is None:
                      return False
                  try:
                      s = socket.socket(family, socket.SOCK_STREAM)
                      s.bind(('localhost', port))
                      s.close()
                      return True
                  except (socket.error, OSError) as exc:
                      if exc.errno == errno.EADDRINUSE:
                          return True
                      elif exc.errno in (
                          errno.EADDRNOTAVAIL,
                          errno.EPROTONOSUPPORT,
                          errno.EAFNOSUPPORT,
                      ):
                          return False
                      else:
                          raise
                  else:
                      return False
              # useipv6 will be set by parseargs
              useipv6 = None
              def checkportisavailable(port):
                  """return true if a port seems free to bind on localhost"""
                  if useipv6:
                      family = socket.AF_INET6
                  else:
                      family = socket.AF_INET
                  try:
                      with contextlib.closing(socket.socket(family, socket.SOCK_STREAM)) as s:
                          s.bind(('localhost', port))
                      return True
                  except PermissionError:
                      return False
                  except socket.error as exc:
                      if WINDOWS and exc.errno == errno.WSAEACCES:
                          return False
                      if exc.errno not in (
                          errno.EADDRINUSE,
                          errno.EADDRNOTAVAIL,
                          errno.EPROTONOSUPPORT,
                      ):
                          raise
                  return False
              closefds = os.name == 'posix'
              def Popen4(cmd, wd, timeout, env=None):
                  processlock.acquire()
                  p = subprocess.Popen(
                      _bytes2sys(cmd),
                      shell=True,
                      bufsize=-1,
                      cwd=_bytes2sys(wd),
                      env=env,
                      close_fds=closefds,
                      stdin=subprocess.PIPE,
                      stdout=subprocess.PIPE,
                      stderr=subprocess.STDOUT,
                  )
                  processlock.release()
                  p.fromchild = p.stdout
                  p.tochild = p.stdin
                  p.childerr = p.stderr
                  p.timeout = False
                  if timeout:
                      def t():
                          start = time.time()
                          while time.time() - start < timeout and p.returncode is None:
                              time.sleep(0.1)
                          p.timeout = True
                          vlog('# Timout reached for process %d' % p.pid)
                          if p.returncode is None:
                              terminate(p)
                      threading.Thread(target=t).start()
                  return p
              if sys.executable:
                  sysexecutable = sys.executable
              elif os.environ.get('PYTHONEXECUTABLE'):
                  sysexecutable = os.environ['PYTHONEXECUTABLE']
              elif os.environ.get('PYTHON'):
                  sysexecutable = os.environ['PYTHON']
              else:
                  raise AssertionError('Could not find Python interpreter')
              PYTHON = _sys2bytes(sysexecutable.replace('\\', '/'))
              IMPL_PATH = b'PYTHONPATH'
              if 'java' in sys.platform:
                  IMPL_PATH = b'JYTHONPATH'
              default_defaults = {
                  'jobs': ('HGTEST_JOBS', multiprocessing.cpu_count()),
                  'timeout': ('HGTEST_TIMEOUT', 360),
                  'slowtimeout': ('HGTEST_SLOWTIMEOUT', 1500),
                  'port': ('HGTEST_PORT', 20059),
                  'shell': ('HGTEST_SHELL', 'sh'),
              }
              defaults = default_defaults.copy()
              def canonpath(path):
                  return os.path.realpath(os.path.expanduser(path))
              def which(exe):
                  # shutil.which only accept bytes from 3.8
                  cmd = _bytes2sys(exe)
                  real_exec = shutil.which(cmd)
                  return _sys2bytes(real_exec)
              def parselistfiles(files, listtype, warn=True):
                  entries = dict()
                  for filename in files:
                      try:
                          path = os.path.expanduser(os.path.expandvars(filename))
                          f = open(path, "rb")
                      except FileNotFoundError:
                          if warn:
                              print("warning: no such %s file: %s" % (listtype, filename))
                          continue
                      for line in f.readlines():
                          line = line.split(b'#', 1)[0].strip()
                          if line:
                              # Ensure path entries are compatible with os.path.relpath()
                              entries[os.path.normpath(line)] = filename
                      f.close()
                  return entries
              def parsettestcases(path):
                  """read a .t test file, return a set of test case names
                  If path does not exist, return an empty set.
                  """
                  cases = []
                  try:
                      with open(path, 'rb') as f:
                          for l in f:
                              if l.startswith(b'#testcases '):
                                  cases.append(sorted(l[11:].split()))
                  except FileNotFoundError:
                      pass
                  return cases
              def getparser():
                  """Obtain the OptionParser used by the CLI."""
                  parser = argparse.ArgumentParser(usage='%(prog)s [options] [tests]')
                  selection = parser.add_argument_group('Test Selection')
                  selection.add_argument(
                      '--allow-slow-tests',
                      action='store_true',
                      help='allow extremely slow tests',
                  )
                  selection.add_argument(
                      "--blacklist",
                      action="append",
                      help="skip tests listed in the specified blacklist file",
                  )
                  selection.add_argument(
                      "--changed",
                      help="run tests that are changed in parent rev or working directory",
                  )
                  selection.add_argument(
                      "-k", "--keywords", help="run tests matching keywords"
                  )
                  selection.add_argument(
                      "-r", "--retest", action="store_true", help="retest failed tests"
                  )
                  selection.add_argument(
                      "--test-list",
                      action="append",
                      help="read tests to run from the specified file",
                  )
                  selection.add_argument(
                      "--whitelist",
                      action="append",
                      help="always run tests listed in the specified whitelist file",
                  )
                  selection.add_argument(
                      'tests', metavar='TESTS', nargs='*', help='Tests to run'
                  )
                  harness = parser.add_argument_group('Test Harness Behavior')
                  harness.add_argument(
                      '--bisect-repo',
                      metavar='bisect_repo',
                      help=(
                          "Path of a repo to bisect. Use together with " "--known-good-rev"
                      ),
                  )
                  harness.add_argument(
                      "-d",
                      "--debug",
                      action="store_true",
                      help="debug mode: write output of test scripts to console"
                      " rather than capturing and diffing it (disables timeout)",
                  )
                  harness.add_argument(
                      "-f",
                      "--first",
                      action="store_true",
                      help="exit on the first test failure",
                  )
                  harness.add_argument(
                      "-i",
                      "--interactive",
                      action="store_true",
                      help="prompt to accept changed output",
                  )
                  harness.add_argument(
                      "-j",
                      "--jobs",
                      type=int,
                      help="number of jobs to run in parallel"
                      " (default: $%s or %d)" % defaults['jobs'],
                  )
                  harness.add_argument(
                      "--keep-tmpdir",
                      action="store_true",
                      help="keep temporary directory after running tests",
                  )
                  harness.add_argument(
                      '--known-good-rev',
                      metavar="known_good_rev",
                      help=(
                          "Automatically bisect any failures using this "
                          "revision as a known-good revision."
                      ),
                  )
                  harness.add_argument(
                      "--list-tests",
                      action="store_true",
                      help="list tests instead of running them",
                  )
                  harness.add_argument(
                      "--loop", action="store_true", help="loop tests repeatedly"
                  )
                  harness.add_argument(
                      '--random', action="store_true", help='run tests in random order'
                  )
                  harness.add_argument(
                      '--order-by-runtime',
                      action="store_true",
                      help='run slowest tests first, according to .testtimes',
                  )
                  harness.add_argument(
                      "-p",
                      "--port",
                      type=int,
                      help="port on which servers should listen"
                      " (default: $%s or %d)" % defaults['port'],
                  )
                  harness.add_argument(
                      '--profile-runner',
                      action='store_true',
                      help='run statprof on run-tests',
                  )
                  harness.add_argument(
                      "-R", "--restart", action="store_true", help="restart at last error"
                  )
                  harness.add_argument(
                      "--runs-per-test",
                      type=int,
                      dest="runs_per_test",
                      help="run each test N times (default=1)",
                      default=1,
                  )
                  harness.add_argument(
                      "--shell", help="shell to use (default: $%s or %s)" % defaults['shell']
                  )
                  harness.add_argument(
                      '--showchannels', action='store_true', help='show scheduling channels'
                  )
                  harness.add_argument(
                      "--slowtimeout",
                      type=int,
                      help="kill errant slow tests after SLOWTIMEOUT seconds"
                      " (default: $%s or %d)" % defaults['slowtimeout'],
                  )
                  harness.add_argument(
                      "-t",
                      "--timeout",
                      type=int,
                      help="kill errant tests after TIMEOUT seconds"
                      " (default: $%s or %d)" % defaults['timeout'],
                  )
                  harness.add_argument(
                      "--tmpdir",
                      help="run tests in the given temporary directory"
                      " (implies --keep-tmpdir)",
                  )
                  harness.add_argument(
                      "-v", "--verbose", action="store_true", help="output verbose messages"
                  )
                  hgconf = parser.add_argument_group('Mercurial Configuration')
                  hgconf.add_argument(
                      "--chg",
                      action="store_true",
                      help="install and use chg wrapper in place of hg",
                  )
                  hgconf.add_argument(
                      "--chg-debug",
                      action="store_true",
                      help="show chg debug logs",
                  )
                  hgconf.add_argument(
                      "--rhg",
                      action="store_true",
                      help="install and use rhg Rust implementation in place of hg",
                  )
                  hgconf.add_argument(
                      "--pyoxidized",
                      action="store_true",
                      help="build the hg binary using pyoxidizer",
                  )
                  hgconf.add_argument("--compiler", help="compiler to build with")
                  hgconf.add_argument(
                      '--extra-config-opt',
                      action="append",
                      default=[],
                      help='set the given config opt in the test hgrc',
                  )
                  hgconf.add_argument(
                      "-l",
                      "--local",
                      action="store_true",
                      help="shortcut for --with-hg=<testdir>/../hg, "
                      "--with-rhg=<testdir>/../rust/target/release/rhg if --rhg is set, "
                      "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set",
                  )
                  hgconf.add_argument(
                      "--ipv6",
                      action="store_true",
                      help="prefer IPv6 to IPv4 for network related tests",
                  )
                  hgconf.add_argument(
                      "--pure",
                      action="store_true",
                      help="use pure Python code instead of C extensions",
                  )
                  hgconf.add_argument(
                      "--rust",
                      action="store_true",
                      help="use Rust code alongside C extensions",
                  )
                  hgconf.add_argument(
                      "--no-rust",
                      action="store_true",
                      help="do not use Rust code even if compiled",
                  )
                  hgconf.add_argument(
                      "--with-chg",
                      metavar="CHG",
                      help="use specified chg wrapper in place of hg",
                  )
                  hgconf.add_argument(
                      "--with-rhg",
                      metavar="RHG",
                      help="use specified rhg Rust implementation in place of hg",
                  )
                  hgconf.add_argument(
                      "--with-hg",
                      metavar="HG",
                      help="test using specified hg script rather than a "
                      "temporary installation",
                  )
                  reporting = parser.add_argument_group('Results Reporting')
                  reporting.add_argument(
                      "-C",
                      "--annotate",
                      action="store_true",
                      help="output files annotated with coverage",
                  )
                  reporting.add_argument(
                      "--color",
                      choices=["always", "auto", "never"],
                      default=os.environ.get('HGRUNTESTSCOLOR', 'auto'),
                      help="colorisation: always|auto|never (default: auto)",
                  )
                  reporting.add_argument(
                      "-c",
                      "--cover",
                      action="store_true",
                      help="print a test coverage report",
                  )
                  reporting.add_argument(
                      '--exceptions',
                      action='store_true',
                      help='log all exceptions and generate an exception report',
                  )
                  reporting.add_argument(
                      "-H",
                      "--htmlcov",
                      action="store_true",
                      help="create an HTML report of the coverage of the files",
                  )
                  reporting.add_argument(
                      "--json",
                      action="store_true",
                      help="store test result data in 'report.json' file",
                  )
                  reporting.add_argument(
                      "--outputdir",
                      help="directory to write error logs to (default=test directory)",
                  )
                  reporting.add_argument(
                      "-n", "--nodiff", action="store_true", help="skip showing test changes"
                  )
                  reporting.add_argument(
                      "-S",
                      "--noskips",
                      action="store_true",
                      help="don't report skip tests verbosely",
                  )
                  reporting.add_argument(
                      "--time", action="store_true", help="time how long each test takes"
                  )
                  reporting.add_argument("--view", help="external diff viewer")
                  reporting.add_argument(
                      "--xunit", help="record xunit results at specified path"
                  )
                  for option, (envvar, default) in defaults.items():
                      defaults[option] = type(default)(os.environ.get(envvar, default))
                  parser.set_defaults(**defaults)
                  return parser
              def parseargs(args, parser):
                  """Parse arguments with our OptionParser and validate results."""
                  options = parser.parse_args(args)
                  # jython is always pure
                  if 'java' in sys.platform or '__pypy__' in sys.modules:
                      options.pure = True
                  if platform.python_implementation() != 'CPython' and options.rust:
                      parser.error('Rust extensions are only available with CPython')
                  if options.pure and options.rust:
                      parser.error('--rust cannot be used with --pure')
                  if options.rust and options.no_rust:
                      parser.error('--rust cannot be used with --no-rust')
                  if options.local:
                      if options.with_hg or options.with_rhg or options.with_chg:
                          parser.error(
                              '--local cannot be used with --with-hg or --with-rhg or --with-chg'
                          )
                      if options.pyoxidized:
                          parser.error('--pyoxidized does not work with --local (yet)')
                      testdir = os.path.dirname(_sys2bytes(canonpath(sys.argv[0])))
                      reporootdir = os.path.dirname(testdir)
                      pathandattrs = [(b'hg', 'with_hg')]
                      if options.chg:
                          pathandattrs.append((b'contrib/chg/chg', 'with_chg'))
                      if options.rhg:
                          pathandattrs.append((b'rust/target/release/rhg', 'with_rhg'))
                      for relpath, attr in pathandattrs:
                          binpath = os.path.join(reporootdir, relpath)
                          if not (WINDOWS or os.access(binpath, os.X_OK)):
                              parser.error(
                                  '--local specified, but %r not found or '
                                  'not executable' % binpath
                              )
                          setattr(options, attr, _bytes2sys(binpath))
                  if options.with_hg:
                      options.with_hg = canonpath(_sys2bytes(options.with_hg))
                      if not (
                          os.path.isfile(options.with_hg)
                          and os.access(options.with_hg, os.X_OK)
                      ):
                          parser.error('--with-hg must specify an executable hg script')
                      if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']:
                          msg = 'warning: --with-hg should specify an hg script, not: %s\n'
                          msg %= _bytes2sys(os.path.basename(options.with_hg))
                          sys.stderr.write(msg)
                          sys.stderr.flush()
                  if (options.chg or options.with_chg) and WINDOWS:
                      parser.error('chg does not work on %s' % os.name)
                  if (options.rhg or options.with_rhg) and WINDOWS:
                      parser.error('rhg does not work on %s' % os.name)
                  if options.pyoxidized and not (MACOS or WINDOWS):
                      parser.error('--pyoxidized is currently macOS and Windows only')
                  if options.with_chg:
                      options.chg = False  # no installation to temporary location
                      options.with_chg = canonpath(_sys2bytes(options.with_chg))
                      if not (
                          os.path.isfile(options.with_chg)
                          and os.access(options.with_chg, os.X_OK)
                      ):
                          parser.error('--with-chg must specify a chg executable')
                  if options.with_rhg:
                      options.rhg = False  # no installation to temporary location
                      options.with_rhg = canonpath(_sys2bytes(options.with_rhg))
                      if not (
                          os.path.isfile(options.with_rhg)
                          and os.access(options.with_rhg, os.X_OK)
                      ):
                          parser.error('--with-rhg must specify a rhg executable')
                  if options.chg and options.with_hg:
                      # chg shares installation location with hg
                      parser.error(
                          '--chg does not work when --with-hg is specified '
                          '(use --with-chg instead)'
                      )
                  if options.rhg and options.with_hg:
                      # rhg shares installation location with hg
                      parser.error(
                          '--rhg does not work when --with-hg is specified '
                          '(use --with-rhg instead)'
                      )
                  if options.rhg and options.chg:
                      parser.error('--rhg and --chg do not work together')
                  if options.color == 'always' and not pygmentspresent:
                      sys.stderr.write(
                          'warning: --color=always ignored because '
                          'pygments is not installed\n'
                      )
                  if options.bisect_repo and not options.known_good_rev:
                      parser.error("--bisect-repo cannot be used without --known-good-rev")
                  global useipv6
                  if options.ipv6:
                      useipv6 = checksocketfamily('AF_INET6')
                  else:
                      # only use IPv6 if IPv4 is unavailable and IPv6 is available
                      useipv6 = (not checksocketfamily('AF_INET')) and checksocketfamily(
                          'AF_INET6'
                      )
                  options.anycoverage = options.cover or options.annotate or options.htmlcov
                  if options.anycoverage:
                      try:
                          import coverage
                          coverage.__version__  # silence unused import warning
                      except ImportError:
                          parser.error('coverage options now require the coverage package')
                  if options.anycoverage and options.local:
                      # this needs some path mangling somewhere, I guess
                      parser.error(
                          "sorry, coverage options do not work when --local " "is specified"
                      )
                  if options.anycoverage and options.with_hg:
                      parser.error(
                          "sorry, coverage options do not work when --with-hg " "is specified"
                      )
                  global verbose
                  if options.verbose:
                      verbose = ''
                  if options.tmpdir:
                      options.tmpdir = canonpath(options.tmpdir)
                  if options.jobs < 1:
                      parser.error('--jobs must be positive')
                  if options.interactive and options.debug:
                      parser.error("-i/--interactive and -d/--debug are incompatible")
                  if options.debug:
                      if options.timeout != defaults['timeout']:
                          sys.stderr.write('warning: --timeout option ignored with --debug\n')
                      if options.slowtimeout != defaults['slowtimeout']:
                          sys.stderr.write(
                              'warning: --slowtimeout option ignored with --debug\n'
                          )
                      options.timeout = 0
                      options.slowtimeout = 0
                  if options.blacklist:
                      options.blacklist = parselistfiles(options.blacklist, 'blacklist')
                  if options.whitelist:
                      options.whitelisted = parselistfiles(options.whitelist, 'whitelist')
                  else:
                      options.whitelisted = {}
                  if options.showchannels:
                      options.nodiff = True
                  return options
              def rename(src, dst):
                  """Like os.rename(), trade atomicity and opened files friendliness
                  for existing destination support.
                  """
                  shutil.copy(src, dst)
                  os.remove(src)
              def makecleanable(path):
                  """Try to fix directory permission recursively so that the entire tree
                  can be deleted"""
                  for dirpath, dirnames, _filenames in os.walk(path, topdown=True):
                      for d in dirnames:
                          p = os.path.join(dirpath, d)
                          try:
                              os.chmod(p, os.stat(p).st_mode & 0o777 | 0o700)  # chmod u+rwx
                          except OSError:
                              pass
              _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff)
              def getdiff(expected, output, ref, err):
                  servefail = False
                  lines = []
                  for line in _unified_diff(expected, output, ref, err):
                      if line.startswith(b'+++') or line.startswith(b'---'):
                          line = line.replace(b'\\', b'/')
                          if line.endswith(b' \n'):
                              line = line[:-2] + b'\n'
                      lines.append(line)
                      if not servefail and line.startswith(
                          b'+  abort: child process failed to start'
                      ):
                          servefail = True
                  return servefail, lines
              verbose = False
              def vlog(*msg):
                  """Log only when in verbose mode."""
                  if verbose is False:
                      return
                  return log(*msg)
              # Bytes that break XML even in a CDATA block: control characters 0-31
              # sans \t, \n and \r
              CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]")
              # Match feature conditionalized output lines in the form, capturing the feature
              # list in group 2, and the preceeding line output in group 1:
              #
              #   output..output (feature !)\n
              optline = re.compile(br'(.*) \((.+?) !\)\n$')
              def cdatasafe(data):
                  """Make a string safe to include in a CDATA block.
                  Certain control characters are illegal in a CDATA block, and
                  there's no way to include a ]]> in a CDATA either. This function
                  replaces illegal bytes with ? and adds a space between the ]] so
                  that it won't break the CDATA block.
                  """
                  return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>')
              def log(*msg):
                  """Log something to stdout.
                  Arguments are strings to print.
                  """
                  with iolock:
                      if verbose:
                          print(verbose, end=' ')
                      for m in msg:
                          print(m, end=' ')
                      print()
                      sys.stdout.flush()
              def highlightdiff(line, color):
                  if not color:
                      return line
                  assert pygmentspresent
                  return pygments.highlight(
                      line.decode('latin1'), difflexer, terminal256formatter
                  ).encode('latin1')
              def highlightmsg(msg, color):
                  if not color:
                      return msg
                  assert pygmentspresent
                  return pygments.highlight(msg, runnerlexer, runnerformatter)
              def terminate(proc):
                  """Terminate subprocess"""
                  vlog('# Terminating process %d' % proc.pid)
                  try:
                      proc.terminate()
                  except OSError:
                      pass
              def killdaemons(pidfile):
                  import killdaemons as killmod
                  return killmod.killdaemons(pidfile, tryhard=False, remove=True, logfn=vlog)
              # sysconfig is not thread-safe (https://github.com/python/cpython/issues/92452)
              sysconfiglock = threading.Lock()
              class Test(unittest.TestCase):
                  """Encapsulates a single, runnable test.
                  While this class conforms to the unittest.TestCase API, it differs in that
                  instances need to be instantiated manually. (Typically, unittest.TestCase
                  classes are instantiated automatically by scanning modules.)
                  """
                  # Status code reserved for skipped tests (used by hghave).
                  SKIPPED_STATUS = 80
                  def __init__(
                      self,
                      path,
                      outputdir,
                      tmpdir,
                      keeptmpdir=False,
                      debug=False,
                      first=False,
                      timeout=None,
                      startport=None,
                      extraconfigopts=None,
                      shell=None,
                      hgcommand=None,
                      slowtimeout=None,
                      usechg=False,
                      chgdebug=False,
                      useipv6=False,
                  ):
                      """Create a test from parameters.
                      path is the full path to the file defining the test.
                      tmpdir is the main temporary directory to use for this test.
                      keeptmpdir determines whether to keep the test's temporary directory
                      after execution. It defaults to removal (False).
                      debug mode will make the test execute verbosely, with unfiltered
                      output.
                      timeout controls the maximum run time of the test. It is ignored when
                      debug is True. See slowtimeout for tests with #require slow.
                      slowtimeout overrides timeout if the test has #require slow.
                      startport controls the starting port number to use for this test. Each
                      test will reserve 3 port numbers for execution. It is the caller's
                      responsibility to allocate a non-overlapping port range to Test
                      instances.
                      extraconfigopts is an iterable of extra hgrc config options. Values
                      must have the form "key=value" (something understood by hgrc). Values
                      of the form "foo.key=value" will result in "[foo] key=value".
                      shell is the shell to execute tests in.
                      """
                      if timeout is None:
                          timeout = defaults['timeout']
                      if startport is None:
                          startport = defaults['port']
                      if slowtimeout is None:
                          slowtimeout = defaults['slowtimeout']
                      self.path = path
                      self.relpath = os.path.relpath(path)
                      self.bname = os.path.basename(path)
                      self.name = _bytes2sys(self.bname)
                      self._testdir = os.path.dirname(path)
                      self._outputdir = outputdir
                      self._tmpname = os.path.basename(path)
                      self.errpath = os.path.join(self._outputdir, b'%s.err' % self.bname)
                      self._threadtmp = tmpdir
                      self._keeptmpdir = keeptmpdir
                      self._debug = debug
                      self._first = first
                      self._timeout = timeout
                      self._slowtimeout = slowtimeout
                      self._startport = startport
                      self._extraconfigopts = extraconfigopts or []
                      self._shell = _sys2bytes(shell)
                      self._hgcommand = hgcommand or b'hg'
                      self._usechg = usechg
                      self._chgdebug = chgdebug
                      self._useipv6 = useipv6
                      self._aborted = False
                      self._daemonpids = []
                      self._finished = None
                      self._ret = None
                      self._out = None
                      self._skipped = None
                      self._testtmp = None
                      self._chgsockdir = None
                      self._refout = self.readrefout()
                  def readrefout(self):
                      """read reference output"""
                      # If we're not in --debug mode and reference output file exists,
                      # check test output against it.
                      if self._debug:
                          return None  # to match "out is None"
                      elif os.path.exists(self.refpath):
                          with open(self.refpath, 'rb') as f:
                              return f.read().splitlines(True)
                      else:
                          return []
                  # needed to get base class __repr__ running
                  @property
                  def _testMethodName(self):
                      return self.name
                  def __str__(self):
                      return self.name
                  def shortDescription(self):
                      return self.name
                  def setUp(self):
                      """Tasks to perform before run()."""
                      self._finished = False
                      self._ret = None
                      self._out = None
                      self._skipped = None
                      try:
                          os.mkdir(self._threadtmp)
                      except FileExistsError:
                          pass
                      name = self._tmpname
                      self._testtmp = os.path.join(self._threadtmp, name)
                      os.mkdir(self._testtmp)
                      # Remove any previous output files.
                      if os.path.exists(self.errpath):
                          try:
                              os.remove(self.errpath)
                          except FileNotFoundError:
                              # We might have raced another test to clean up a .err file,
                              # so ignore FileNotFoundError when removing a previous .err
                              # file.
                              pass
                      if self._usechg:
                          self._chgsockdir = os.path.join(
                              self._threadtmp, b'%s.chgsock' % name
                          )
                          os.mkdir(self._chgsockdir)
                  def run(self, result):
                      """Run this test and report results against a TestResult instance."""
                      # This function is extremely similar to unittest.TestCase.run(). Once
                      # we require Python 2.7 (or at least its version of unittest), this
                      # function can largely go away.
                      self._result = result
                      result.startTest(self)
                      try:
                          try:
                              self.setUp()
                          except (KeyboardInterrupt, SystemExit):
                              self._aborted = True
                              raise
                          except Exception:
                              result.addError(self, sys.exc_info())
                              return
                          success = False
                          try:
                              self.runTest()
                          except KeyboardInterrupt:
                              self._aborted = True
                              raise
                          except unittest.SkipTest as e:
                              result.addSkip(self, str(e))
                              # The base class will have already counted this as a
                              # test we "ran", but we want to exclude skipped tests
                              # from those we count towards those run.
                              result.testsRun -= 1
                          except self.failureException as e:
                              # This differs from unittest in that we don't capture
                              # the stack trace. This is for historical reasons and
                              # this decision could be revisited in the future,
                              # especially for PythonTest instances.
                              if result.addFailure(self, str(e)):
                                  success = True
                          except Exception:
                              result.addError(self, sys.exc_info())
                          else:
                              success = True
                          try:
                              self.tearDown()
                          except (KeyboardInterrupt, SystemExit):
                              self._aborted = True
                              raise
                          except Exception:
                              result.addError(self, sys.exc_info())
                              success = False
                          if success:
                              result.addSuccess(self)
                      finally:
                          result.stopTest(self, interrupted=self._aborted)
                  def runTest(self):
                      """Run this test instance.
                      This will return a tuple describing the result of the test.
                      """
                      env = self._getenv()
                      self._genrestoreenv(env)
                      self._daemonpids.append(env['DAEMON_PIDS'])
                      self._createhgrc(env['HGRCPATH'])
                      vlog('# Test', self.name)
                      ret, out = self._run(env)
                      self._finished = True
                      self._ret = ret
                      self._out = out
                      def describe(ret):
                          if ret < 0:
                              return 'killed by signal: %d' % -ret
                          return 'returned error code %d' % ret
                      self._skipped = False
                      if ret == self.SKIPPED_STATUS:
                          if out is None:  # Debug mode, nothing to parse.
                              missing = ['unknown']
                              failed = None
                          else:
                              missing, failed = TTest.parsehghaveoutput(out)
                          if not missing:
                              missing = ['skipped']
                          if failed:
                              self.fail('hg have failed checking for %s' % failed[-1])
                          else:
                              self._skipped = True
                              raise unittest.SkipTest(missing[-1])
                      elif ret == 'timeout':
                          self.fail('timed out')
                      elif ret is False:
                          self.fail('no result code from test')
                      elif out != self._refout:
                          # Diff generation may rely on written .err file.
                          if (
                              (ret != 0 or out != self._refout)
                              and not self._skipped
                              and not self._debug
                          ):
                              with open(self.errpath, 'wb') as f:
                                  for line in out:
                                      f.write(line)
                          # The result object handles diff calculation for us.
                          with firstlock:
                              if self._result.addOutputMismatch(self, ret, out, self._refout):
                                  # change was accepted, skip failing
                                  return
                              if self._first:
                                  global firsterror
                                  firsterror = True
                          if ret:
                              msg = 'output changed and ' + describe(ret)
                          else:
                              msg = 'output changed'
                          self.fail(msg)
                      elif ret:
                          self.fail(describe(ret))
                  def tearDown(self):
                      """Tasks to perform after run()."""
                      for entry in self._daemonpids:
                          killdaemons(entry)
                      self._daemonpids = []
                      if self._keeptmpdir:
                          log(
                              '\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s'
                              % (
                                  _bytes2sys(self._testtmp),
                                  _bytes2sys(self._threadtmp),
                              )
                          )
                      else:
                          try:
                              shutil.rmtree(self._testtmp)
                          except OSError:
                              # unreadable directory may be left in $TESTTMP; fix permission
                              # and try again
                              makecleanable(self._testtmp)
                              shutil.rmtree(self._testtmp, True)
                          shutil.rmtree(self._threadtmp, True)
                      if self._usechg:
                          # chgservers will stop automatically after they find the socket
                          # files are deleted
                          shutil.rmtree(self._chgsockdir, True)
                      if (
                          (self._ret != 0 or self._out != self._refout)
                          and not self._skipped
                          and not self._debug
                          and self._out
                      ):
                          with open(self.errpath, 'wb') as f:
                              for line in self._out:
                                  f.write(line)
                      vlog("# Ret was:", self._ret, '(%s)' % self.name)
                  def _run(self, env):
                      # This should be implemented in child classes to run tests.
                      raise unittest.SkipTest('unknown test type')
                  def abort(self):
                      """Terminate execution of this test."""
                      self._aborted = True
                  def _portmap(self, i):
                      offset = b'' if i == 0 else b'%d' % i
                      return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset)
                  def _getreplacements(self):
                      """Obtain a mapping of text replacements to apply to test output.
                      Test output needs to be normalized so it can be compared to expected
                      output. This function defines how some of that normalization will
                      occur.
                      """
                      r = [
                          # This list should be parallel to defineport in _getenv
                          self._portmap(0),
                          self._portmap(1),
                          self._portmap(2),
                          (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'),
                          (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'),
                      ]
                      r.append((self._escapepath(self._testtmp), b'$TESTTMP'))
                      if WINDOWS:
                          # JSON output escapes backslashes in Windows paths, so also catch a
                          # double-escape.
                          replaced = self._testtmp.replace(b'\\', br'\\')
                          r.append((self._escapepath(replaced), b'$STR_REPR_TESTTMP'))
                      replacementfile = os.path.join(self._testdir, b'common-pattern.py')
                      if os.path.exists(replacementfile):
                          data = {}
                          with open(replacementfile, mode='rb') as source:
                              # the intermediate 'compile' step help with debugging
                              code = compile(source.read(), replacementfile, 'exec')
                              exec(code, data)
                              for value in data.get('substitutions', ()):
                                  if len(value) != 2:
                                      msg = 'malformatted substitution in %s: %r'
                                      msg %= (replacementfile, value)
                                      raise ValueError(msg)
                                  r.append(value)
                      return r
                  def _escapepath(self, p):
                      if WINDOWS:
                          return b''.join(
                              c.isalpha()
                              and b'[%s%s]' % (c.lower(), c.upper())
                              or c in b'/\\'
                              and br'[/\\]'
                              or c.isdigit()
                              and c
                              or b'\\' + c
                              for c in [p[i : i + 1] for i in range(len(p))]
                          )
                      else:
                          return re.escape(p)
                  def _localip(self):
                      if self._useipv6:
                          return b'::1'
                      else:
                          return b'127.0.0.1'
                  def _genrestoreenv(self, testenv):
                      """Generate a script that can be used by tests to restore the original
                      environment."""
                      # Put the restoreenv script inside self._threadtmp
                      scriptpath = os.path.join(self._threadtmp, b'restoreenv.sh')
                      testenv['HGTEST_RESTOREENV'] = _bytes2sys(scriptpath)
                      # Only restore environment variable names that the shell allows
                      # us to export.
                      name_regex = re.compile('^[a-zA-Z][a-zA-Z0-9_]*$')
                      # Do not restore these variables; otherwise tests would fail.
                      reqnames = {'PYTHON', 'TESTDIR', 'TESTTMP'}
                      with open(scriptpath, 'w') as envf:
                          for name, value in origenviron.items():
                              if not name_regex.match(name):
                                  # Skip environment variables with unusual names not
                                  # allowed by most shells.
                                  continue
                              if name in reqnames:
                                  continue
                              envf.write('%s=%s\n' % (name, shellquote(value)))
                          for name in testenv:
                              if name in origenviron or name in reqnames:
                                  continue
                              envf.write('unset %s\n' % (name,))
                  def _getenv(self):
                      """Obtain environment variables to use during test execution."""
                      def defineport(i):
                          offset = '' if i == 0 else '%s' % i
                          env["HGPORT%s" % offset] = '%s' % (self._startport + i)
                      env = os.environ.copy()
                      with sysconfiglock:
                          env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or ''
                      env['HGEMITWARNINGS'] = '1'
                      env['TESTTMP'] = _bytes2sys(self._testtmp)
                      # the FORWARD_SLASH version is useful when running `sh` on non unix
                      # system (e.g. Windows)
                      env['TESTTMP_FORWARD_SLASH'] = env['TESTTMP'].replace(os.sep, '/')
                      uid_file = os.path.join(_bytes2sys(self._testtmp), 'UID')
                      env['HGTEST_UUIDFILE'] = uid_file
                      env['TESTNAME'] = self.name
                      env['HOME'] = _bytes2sys(self._testtmp)
                      if WINDOWS:
                          env['REALUSERPROFILE'] = env['USERPROFILE']
                          # py3.8+ ignores HOME: https://bugs.python.org/issue36264
                          env['USERPROFILE'] = env['HOME']
                      formated_timeout = _bytes2sys(b"%d" % default_defaults['timeout'][1])
                      env['HGTEST_TIMEOUT_DEFAULT'] = formated_timeout
                      env['HGTEST_TIMEOUT'] = _bytes2sys(b"%d" % self._timeout)
                      # This number should match portneeded in _getport
                      for port in range(3):
                          # This list should be parallel to _portmap in _getreplacements
                          defineport(port)
                      env["HGRCPATH"] = _bytes2sys(os.path.join(self._threadtmp, b'.hgrc'))
                      env["DAEMON_PIDS"] = _bytes2sys(
                          os.path.join(self._threadtmp, b'daemon.pids')
                      )
                      env["HGEDITOR"] = (
                          '"' + sysexecutable + '"' + ' -c "import sys; sys.exit(0)"'
                      )
                      env["HGUSER"] = "test"
                      env["HGENCODING"] = "ascii"
                      env["HGENCODINGMODE"] = "strict"
                      env["HGHOSTNAME"] = "test-hostname"
                      env['HGIPV6'] = str(int(self._useipv6))
                      # See contrib/catapipe.py for how to use this functionality.
                      if 'HGTESTCATAPULTSERVERPIPE' not in env:
                          # If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the
                          # non-test one in as a default, otherwise set to devnull
                          env['HGTESTCATAPULTSERVERPIPE'] = env.get(
                              'HGCATAPULTSERVERPIPE', os.devnull
                          )
                      extraextensions = []
                      for opt in self._extraconfigopts:
                          section, key = opt.split('.', 1)
                          if section != 'extensions':
                              continue
                          name = key.split('=', 1)[0]
                          extraextensions.append(name)
                      if extraextensions:
                          env['HGTESTEXTRAEXTENSIONS'] = ' '.join(extraextensions)
                      # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw
                      # IP addresses.
                      env['LOCALIP'] = _bytes2sys(self._localip())
                      # This has the same effect as Py_LegacyWindowsStdioFlag in exewrapper.c,
                      # but this is needed for testing python instances like dummyssh,
                      # dummysmtpd.py, and dumbhttp.py.
                      if WINDOWS:
                          env['PYTHONLEGACYWINDOWSSTDIO'] = '1'
                      # Modified HOME in test environment can confuse Rust tools. So set
                      # CARGO_HOME and RUSTUP_HOME automatically if a Rust toolchain is
                      # present and these variables aren't already defined.
                      cargo_home_path = os.path.expanduser('~/.cargo')
                      rustup_home_path = os.path.expanduser('~/.rustup')
                      if os.path.exists(cargo_home_path) and b'CARGO_HOME' not in osenvironb:
                          env['CARGO_HOME'] = cargo_home_path
                      if (
                          os.path.exists(rustup_home_path)
                          and b'RUSTUP_HOME' not in osenvironb
                      ):
                          env['RUSTUP_HOME'] = rustup_home_path
                      # Reset some environment variables to well-known values so that
                      # the tests produce repeatable output.
                      env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C'
                      env['TZ'] = 'GMT'
                      env["EMAIL"] = "Foo Bar <foo.bar@example.com>"
                      env['COLUMNS'] = '80'
                      env['TERM'] = 'xterm'
                      dropped = [
                          'CDPATH',
                          'CHGDEBUG',
                          'EDITOR',
                          'GREP_OPTIONS',
                          'HG',
                          'HGMERGE',
                          'HGPLAIN',
                          'HGPLAINEXCEPT',
                          'HGPROF',
                          'http_proxy',
                          'no_proxy',
                          'NO_PROXY',
                          'PAGER',
                          'VISUAL',
                      ]
                      for k in dropped:
                          if k in env:
                              del env[k]
                      # unset env related to hooks
                      for k in list(env):
                          if k.startswith('HG_'):
                              del env[k]
                      if self._usechg:
                          env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server')
                      if self._chgdebug:
                          env['CHGDEBUG'] = 'true'
                      return env
                  def _createhgrc(self, path):
                      """Create an hgrc file for this test."""
                      with open(path, 'wb') as hgrc:
                          hgrc.write(b'[ui]\n')
                          hgrc.write(b'slash = True\n')
                          hgrc.write(b'interactive = False\n')
                          hgrc.write(b'detailed-exit-code = True\n')
                          hgrc.write(b'merge = internal:merge\n')
                          hgrc.write(b'mergemarkers = detailed\n')
                          hgrc.write(b'promptecho = True\n')
                          dummyssh = os.path.join(self._testdir, b'dummyssh')
                          hgrc.write(b'ssh = "%s" "%s"\n' % (PYTHON, dummyssh))
                          hgrc.write(b'timeout.warn=15\n')
                          hgrc.write(b'[chgserver]\n')
                          hgrc.write(b'idletimeout=60\n')
                          hgrc.write(b'[defaults]\n')
                          hgrc.write(b'[devel]\n')
                          hgrc.write(b'all-warnings = true\n')
                          hgrc.write(b'default-date = 0 0\n')
                          hgrc.write(b'[largefiles]\n')
                          hgrc.write(
                              b'usercache = %s\n'
                              % (os.path.join(self._testtmp, b'.cache/largefiles'))
                          )
                          hgrc.write(b'[lfs]\n')
                          hgrc.write(
                              b'usercache = %s\n'
                              % (os.path.join(self._testtmp, b'.cache/lfs'))
                          )
                          hgrc.write(b'[web]\n')
                          hgrc.write(b'address = localhost\n')
                          hgrc.write(b'ipv6 = %r\n' % self._useipv6)
                          hgrc.write(b'server-header = testing stub value\n')
                          for opt in self._extraconfigopts:
                              section, key = _sys2bytes(opt).split(b'.', 1)
                              assert b'=' in key, (
                                  'extra config opt %s must ' 'have an = for assignment' % opt
                              )
                              hgrc.write(b'[%s]\n%s\n' % (section, key))
                  def fail(self, msg):
                      # unittest differentiates between errored and failed.
                      # Failed is denoted by AssertionError (by default at least).
                      raise AssertionError(msg)
                  def _runcommand(self, cmd, env, normalizenewlines=False):
                      """Run command in a sub-process, capturing the output (stdout and
                      stderr).
                      Return a tuple (exitcode, output). output is None in debug mode.
                      """
                      if self._debug:
                          proc = subprocess.Popen(
                              _bytes2sys(cmd),
                              shell=True,
                              close_fds=closefds,
                              cwd=_bytes2sys(self._testtmp),
                              env=env,
                          )
                          ret = proc.wait()
                          return (ret, None)
                      proc = Popen4(cmd, self._testtmp, self._timeout, env)
                      def cleanup():
                          terminate(proc)
                          ret = proc.wait()
                          if ret == 0:
                              ret = signal.SIGTERM << 8
                          killdaemons(env['DAEMON_PIDS'])
                          return ret
                      proc.tochild.close()
                      try:
                          output = proc.fromchild.read()
                      except KeyboardInterrupt:
                          vlog('# Handling keyboard interrupt')
                          cleanup()
                          raise
                      ret = proc.wait()
                      if wifexited(ret):
                          ret = os.WEXITSTATUS(ret)
                      if proc.timeout:
                          ret = 'timeout'
                      if ret:
                          killdaemons(env['DAEMON_PIDS'])
                      for s, r in self._getreplacements():
                          output = re.sub(s, r, output)
                      if normalizenewlines:
                          output = output.replace(b'\r\n', b'\n')
                      return ret, output.splitlines(True)
              class PythonTest(Test):
                  """A Python-based test."""
                  @property
                  def refpath(self):
                      return os.path.join(self._testdir, b'%s.out' % self.bname)
                  def _run(self, env):
                      # Quote the python(3) executable for Windows
                      cmd = b'"%s" "%s"' % (PYTHON, self.path)
                      vlog("# Running", cmd.decode("utf-8"))
                      result = self._runcommand(cmd, env, normalizenewlines=WINDOWS)
                      if self._aborted:
                          raise KeyboardInterrupt()
                      return result
              # Some glob patterns apply only in some circumstances, so the script
              # might want to remove (glob) annotations that otherwise should be
              # retained.
              checkcodeglobpats = [
                  # On Windows it looks like \ doesn't require a (glob), but we know
                  # better.
                  re.compile(br'^pushing to \$TESTTMP/.*[^)]$'),
                  re.compile(br'^moving \S+/.*[^)]$'),
                  re.compile(br'^pulling from \$TESTTMP/.*[^)]$'),
                  # Not all platforms have 127.0.0.1 as loopback (though most do),
                  # so we always glob that too.
                  re.compile(br'.*\$LOCALIP.*$'),
              ]
              bchr = lambda x: bytes([x])
              WARN_UNDEFINED = 1
              WARN_YES = 2
              WARN_NO = 3
              MARK_OPTIONAL = b" (?)\n"
              def isoptional(line):
                  return line.endswith(MARK_OPTIONAL)
              class TTest(Test):
                  """A "t test" is a test backed by a .t file."""
                  SKIPPED_PREFIX = b'skipped: '
                  FAILED_PREFIX = b'hghave check failed: '
                  NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search
                  ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub
                  ESCAPEMAP = {bchr(i): br'\x%02x' % i for i in range(256)}
                  ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'})
                  def __init__(self, path, *args, **kwds):
                      # accept an extra "case" parameter
                      case = kwds.pop('case', [])
                      self._case = case
                      self._allcases = {x for y in parsettestcases(path) for x in y}
                      super(TTest, self).__init__(path, *args, **kwds)
                      if case:
                          casepath = b'#'.join(case)
                          self.name = '%s#%s' % (self.name, _bytes2sys(casepath))
                          self.errpath = b'%s#%s.err' % (self.errpath[:-4], casepath)
                          self._tmpname += b'-%s' % casepath.replace(b'#', b'-')
                      self._have = {}
                  @property
                  def refpath(self):
                      return os.path.join(self._testdir, self.bname)
                  def _run(self, env):
                      with open(self.path, 'rb') as f:
                          lines = f.readlines()
                      # .t file is both reference output and the test input, keep reference
                      # output updated with the the test input. This avoids some race
                      # conditions where the reference output does not match the actual test.
                      if self._refout is not None:
                          self._refout = lines
                      salt, script, after, expected = self._parsetest(lines)
                      # Write out the generated script.
                      fname = b'%s.sh' % self._testtmp
                      with open(fname, 'wb') as f:
                          for l in script:
                              f.write(l)
                      cmd = b'%s "%s"' % (self._shell, fname)
                      vlog("# Running", cmd.decode("utf-8"))
                      exitcode, output = self._runcommand(cmd, env)
                      if self._aborted:
                          raise KeyboardInterrupt()
                      # Do not merge output if skipped. Return hghave message instead.
                      # Similarly, with --debug, output is None.
                      if exitcode == self.SKIPPED_STATUS or output is None:
                          return exitcode, output
                      return self._processoutput(exitcode, output, salt, after, expected)
                  def _hghave(self, reqs):
                      allreqs = b' '.join(reqs)
                      self._detectslow(reqs)
                      if allreqs in self._have:
                          return self._have.get(allreqs)
                      # TODO do something smarter when all other uses of hghave are gone.
                      runtestdir = osenvironb[b'RUNTESTDIR']
                      tdir = runtestdir.replace(b'\\', b'/')
                      proc = Popen4(
                          b'%s -c "%s/hghave %s"' % (self._shell, tdir, allreqs),
                          self._testtmp,
 ,
                          self._getenv(),
                      )
                      stdout, stderr = proc.communicate()
                      ret = proc.wait()
                      if wifexited(ret):
                          ret = os.WEXITSTATUS(ret)
                      if ret == 2:
                          print(stdout.decode('utf-8'))
                          sys.exit(1)
                      if ret != 0:
                          self._have[allreqs] = (False, stdout)
                          return False, stdout
                      self._have[allreqs] = (True, None)
                      return True, None
                  def _detectslow(self, reqs):
                      """update the timeout of slow test when appropriate"""
                      if b'slow' in reqs:
                          self._timeout = self._slowtimeout
                  def _iftest(self, args):
                      # implements "#if"
                      reqs = []
                      for arg in args:
                          if arg.startswith(b'no-') and arg[3:] in self._allcases:
                              if arg[3:] in self._case:
                                  return False
                          elif arg in self._allcases:
                              if arg not in self._case:
                                  return False
                          else:
                              reqs.append(arg)
                      self._detectslow(reqs)
                      return self._hghave(reqs)[0]
                  def _parsetest(self, lines):
                      # We generate a shell script which outputs unique markers to line
                      # up script results with our source. These markers include input
                      # line number and the last return code.
                      salt = b"SALT%d" % time.time()
                      def addsalt(line, inpython):
                          if inpython:
                              script.append(b'%s %d 0\n' % (salt, line))
                          else:
                              script.append(b'echo %s %d $?\n' % (salt, line))
                      activetrace = []
                      session = str(uuid.uuid4()).encode('ascii')
                      hgcatapult = os.getenv('HGTESTCATAPULTSERVERPIPE') or os.getenv(
                          'HGCATAPULTSERVERPIPE'
                      )
                      def toggletrace(cmd=None):
                          if not hgcatapult or hgcatapult == os.devnull:
                              return
                          if activetrace:
                              script.append(
                                  b'echo END %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n'
                                  % (session, activetrace[0])
                              )
                          if cmd is None:
                              return
                          if isinstance(cmd, str):
                              quoted = shellquote(cmd.strip())
                          else:
                              quoted = shellquote(cmd.strip().decode('utf8')).encode('utf8')
                          quoted = quoted.replace(b'\\', b'\\\\')
                          script.append(
                              b'echo START %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n'
                              % (session, quoted)
                          )
                          activetrace[0:] = [quoted]
                      script = []
                      # After we run the shell script, we re-unify the script output
                      # with non-active parts of the source, with synchronization by our
                      # SALT line number markers. The after table contains the non-active
                      # components, ordered by line number.
                      after = {}
                      # Expected shell script output.
                      expected = {}
                      pos = prepos = -1
                      # The current stack of conditionnal section.
                      # Each relevant conditionnal section can have the following value:
                      #  - True:  we should run this block
                      #  - False: we should skip this block
                      #  - None:  The parent block is skipped,
                      #           (no branch of this one will ever run)
                      condition_stack = []
                      def run_line():
                          """return True if the current line should be run"""
                          if not condition_stack:
                              return True
                          return bool(condition_stack[-1])
                      def push_conditional_block(should_run):
                          """Push a new conditional context, with its initial state
                          i.e. entry a #if block"""
                          if not run_line():
                              condition_stack.append(None)
                          else:
                              condition_stack.append(should_run)
                      def flip_conditional():
                          """reverse the current condition state
                          i.e. enter a #else
                          """
                          assert condition_stack
                          if condition_stack[-1] is not None:
                              condition_stack[-1] = not condition_stack[-1]
                      def pop_conditional():
                          """exit the current skipping context
                          i.e. reach the #endif"""
                          assert condition_stack
                          condition_stack.pop()
                      # We keep track of whether or not we're in a Python block so we
                      # can generate the surrounding doctest magic.
                      inpython = False
                      if self._debug:
                          script.append(b'set -x\n')
                      if os.getenv('MSYSTEM'):
                          script.append(b'alias pwd="pwd -W"\n')
                      if hgcatapult and hgcatapult != os.devnull:
                          hgcatapult = hgcatapult.encode('utf8')
                          cataname = self.name.encode('utf8')
                          # Kludge: use a while loop to keep the pipe from getting
                          # closed by our echo commands. The still-running file gets
                          # reaped at the end of the script, which causes the while
                          # loop to exit and closes the pipe. Sigh.
                          script.append(
                              b'rtendtracing() {\n'
                              b'  echo END %(session)s %(name)s >> %(catapult)s\n'
                              b'  rm -f "$TESTTMP/.still-running"\n'
                              b'}\n'
                              b'trap "rtendtracing" 0\n'
                              b'touch "$TESTTMP/.still-running"\n'
                              b'while [ -f "$TESTTMP/.still-running" ]; do sleep 1; done '
                              b'> %(catapult)s &\n'
                              b'HGCATAPULTSESSION=%(session)s ; export HGCATAPULTSESSION\n'
                              b'echo START %(session)s %(name)s >> %(catapult)s\n'
                              % {
                                  b'name': cataname,
                                  b'session': session,
                                  b'catapult': hgcatapult,
                              }
                          )
                      if self._case:
                          casestr = b'#'.join(self._case)
                          if isinstance(casestr, str):
                              quoted = shellquote(casestr)
                          else:
                              quoted = shellquote(casestr.decode('utf8')).encode('utf8')
                          script.append(b'TESTCASE=%s\n' % quoted)
                          script.append(b'export TESTCASE\n')
                      n = 0
                      for n, l in enumerate(lines):
                          if not l.endswith(b'\n'):
                              l += b'\n'
                          if l.startswith(b'#require'):
                              lsplit = l.split()
                              if len(lsplit) < 2 or lsplit[0] != b'#require':
                                  after.setdefault(pos, []).append(
                                      b'  !!! invalid #require\n'
                                  )
                              if run_line():
                                  haveresult, message = self._hghave(lsplit[1:])
                                  if not haveresult:
                                      script = [b'echo "%s"\nexit 80\n' % message]
                                      break
                              after.setdefault(pos, []).append(l)
                          elif l.startswith(b'#if'):
                              lsplit = l.split()
                              if len(lsplit) < 2 or lsplit[0] != b'#if':
                                  after.setdefault(pos, []).append(b'  !!! invalid #if\n')
                              push_conditional_block(self._iftest(lsplit[1:]))
                              after.setdefault(pos, []).append(l)
                          elif l.startswith(b'#else'):
                              if not condition_stack:
                                  after.setdefault(pos, []).append(b'  !!! missing #if\n')
                              flip_conditional()
                              after.setdefault(pos, []).append(l)
                          elif l.startswith(b'#endif'):
                              if not condition_stack:
                                  after.setdefault(pos, []).append(b'  !!! missing #if\n')
                              pop_conditional()
                              after.setdefault(pos, []).append(l)
                          elif not run_line():
                              after.setdefault(pos, []).append(l)
                          elif l.startswith(b'  >>> '):  # python inlines
                              after.setdefault(pos, []).append(l)
                              prepos = pos
                              pos = n
                              if not inpython:
                                  # We've just entered a Python block. Add the header.
                                  inpython = True
                                  addsalt(prepos, False)  # Make sure we report the exit code.
                                  script.append(b'"%s" -m heredoctest <<EOF\n' % PYTHON)
                              addsalt(n, True)
                              script.append(l[2:])
                          elif l.startswith(b'  ... '):  # python inlines
                              after.setdefault(prepos, []).append(l)
                              script.append(l[2:])
                          elif l.startswith(b'  $ '):  # commands
                              if inpython:
                                  script.append(b'EOF\n')
                                  inpython = False
                              after.setdefault(pos, []).append(l)
                              prepos = pos
                              pos = n
                              addsalt(n, False)
                              rawcmd = l[4:]
                              cmd = rawcmd.split()
                              toggletrace(rawcmd)
                              if len(cmd) == 2 and cmd[0] == b'cd':
                                  rawcmd = b'cd %s || exit 1\n' % cmd[1]
                              script.append(rawcmd)
                          elif l.startswith(b'  > '):  # continuations
                              after.setdefault(prepos, []).append(l)
                              script.append(l[4:])
                          elif l.startswith(b'  '):  # results
                              # Queue up a list of expected results.
                              expected.setdefault(pos, []).append(l[2:])
                          else:
                              if inpython:
                                  script.append(b'EOF\n')
                                  inpython = False
                              # Non-command/result. Queue up for merged output.
                              after.setdefault(pos, []).append(l)
                      if inpython:
                          script.append(b'EOF\n')
                      if condition_stack:
                          after.setdefault(pos, []).append(b'  !!! missing #endif\n')
                      addsalt(n + 1, False)
                      # Need to end any current per-command trace
                      if activetrace:
                          toggletrace()
                      return salt, script, after, expected
                  def _processoutput(self, exitcode, output, salt, after, expected):
                      # Merge the script output back into a unified test.
                      warnonly = WARN_UNDEFINED  # 1: not yet; 2: yes; 3: for sure not
                      if exitcode != 0:
                          warnonly = WARN_NO
                      pos = -1
                      postout = []
                      for out_rawline in output:
                          out_line, cmd_line = out_rawline, None
                          if salt in out_rawline:
                              out_line, cmd_line = out_rawline.split(salt, 1)
                          pos, postout, warnonly = self._process_out_line(
                              out_line, pos, postout, expected, warnonly
                          )
                          pos, postout = self._process_cmd_line(cmd_line, pos, postout, after)
                      if pos in after:
                          postout += after.pop(pos)
                      if warnonly == WARN_YES:
                          exitcode = False  # Set exitcode to warned.
                      return exitcode, postout
                  def _process_out_line(self, out_line, pos, postout, expected, warnonly):
                      while out_line:
                          if not out_line.endswith(b'\n'):
                              out_line += b' (no-eol)\n'
                          # Find the expected output at the current position.
                          els = [None]
                          if expected.get(pos, None):
                              els = expected[pos]
                          optional = []
                          for i, el in enumerate(els):
                              r = False
                              if el:
                                  r, exact = self.linematch(el, out_line)
                              if isinstance(r, str):
                                  if r == '-glob':
                                      out_line = ''.join(el.rsplit(' (glob)', 1))
                                      r = ''  # Warn only this line.
                                  elif r == "retry":
                                      postout.append(b'  ' + el)
                                  else:
                                      log('\ninfo, unknown linematch result: %r\n' % r)
                                      r = False
                              if r:
                                  els.pop(i)
                                  break
                              if el:
                                  if isoptional(el):
                                      optional.append(i)
                                  else:
                                      m = optline.match(el)
                                      if m:
                                          conditions = [c for c in m.group(2).split(b' ')]
                                          if not self._iftest(conditions):
                                              optional.append(i)
                                  if exact:
                                      # Don't allow line to be matches against a later
                                      # line in the output
                                      els.pop(i)
                                      break
                          if r:
                              if r == "retry":
                                  continue
                              # clean up any optional leftovers
                              for i in optional:
                                  postout.append(b'  ' + els[i])
                              for i in reversed(optional):
                                  del els[i]
                              postout.append(b'  ' + el)
                          else:
                              if self.NEEDESCAPE(out_line):
                                  out_line = TTest._stringescape(
                                      b'%s (esc)\n' % out_line.rstrip(b'\n')
                                  )
                              postout.append(b'  ' + out_line)  # Let diff deal with it.
                              if r != '':  # If line failed.
                                  warnonly = WARN_NO
                              elif warnonly == WARN_UNDEFINED:
                                  warnonly = WARN_YES
                          break
                      else:
                          # clean up any optional leftovers
                          while expected.get(pos, None):
                              el = expected[pos].pop(0)
                              if el:
                                  if not isoptional(el):
                                      m = optline.match(el)
                                      if m:
                                          conditions = [c for c in m.group(2).split(b' ')]
                                          if self._iftest(conditions):
                                              # Don't append as optional line
                                              continue
                                      else:
                                          continue
                              postout.append(b'  ' + el)
                      return pos, postout, warnonly
                  def _process_cmd_line(self, cmd_line, pos, postout, after):
                      """process a "command" part of a line from unified test output"""
                      if cmd_line:
                          # Add on last return code.
                          ret = int(cmd_line.split()[1])
                          if ret != 0:
                              postout.append(b'  [%d]\n' % ret)
                          if pos in after:
                              # Merge in non-active test bits.
                              postout += after.pop(pos)
                          pos = int(cmd_line.split()[0])
                      return pos, postout
                  @staticmethod
                  def rematch(el, l):
                      try:
                          # parse any flags at the beginning of the regex. Only 'i' is
                          # supported right now, but this should be easy to extend.
                          flags, el = re.match(br'^(\(\?i\))?(.*)', el).groups()[0:2]
                          flags = flags or b''
                          el = flags + b'(?:' + el + b')'
                          # use \Z to ensure that the regex matches to the end of the string
                          if WINDOWS:
                              return re.match(el + br'\r?\n\Z', l)
                          return re.match(el + br'\n\Z', l)
                      except re.error:
                          # el is an invalid regex
                          return False
                  @staticmethod
                  def globmatch(el, l):
                      # The only supported special characters are * and ? plus / which also
                      # matches \ on windows. Escaping of these characters is supported.
                      if el + b'\n' == l:
                          if os.altsep:
                              # matching on "/" is not needed for this line
                              for pat in checkcodeglobpats:
                                  if pat.match(el):
                                      return True
                              return b'-glob'
                          return True
                      el = el.replace(b'$LOCALIP', b'*')
                      i, n = 0, len(el)
                      res = b''
                      while i < n:
                          c = el[i : i + 1]
                          i += 1
                          if c == b'\\' and i < n and el[i : i + 1] in b'*?\\/':
                              res += el[i - 1 : i + 1]
                              i += 1
                          elif c == b'*':
                              res += b'.*'
                          elif c == b'?':
                              res += b'.'
                          elif c == b'/' and os.altsep:
                              res += b'[/\\\\]'
                          else:
                              res += re.escape(c)
                      return TTest.rematch(res, l)
                  def linematch(self, el, l):
                      if el == l:  # perfect match (fast)
                          return True, True
                      retry = False
                      if isoptional(el):
                          retry = "retry"
                          el = el[: -len(MARK_OPTIONAL)] + b"\n"
                      else:
                          m = optline.match(el)
                          if m:
                              conditions = [c for c in m.group(2).split(b' ')]
                              el = m.group(1) + b"\n"
                              if not self._iftest(conditions):
                                  # listed feature missing, should not match
                                  return "retry", False
                      if el.endswith(b" (esc)\n"):
                          el = el[:-7].decode('unicode_escape') + '\n'
                          el = el.encode('latin-1')
                      if el == l or WINDOWS and el[:-1] + b'\r\n' == l:
                          return True, True
                      if el.endswith(b" (re)\n"):
                          return (TTest.rematch(el[:-6], l) or retry), False
                      if el.endswith(b" (glob)\n"):
                          # ignore '(glob)' added to l by 'replacements'
                          if l.endswith(b" (glob)\n"):
                              l = l[:-8] + b"\n"
                          return (TTest.globmatch(el[:-8], l) or retry), False
                      if os.altsep:
                          _l = l.replace(b'\\', b'/')
                          if el == _l or WINDOWS and el[:-1] + b'\r\n' == _l:
                              return True, True
                      return retry, True
                  @staticmethod
                  def parsehghaveoutput(lines):
                      """Parse hghave log lines.
                      Return tuple of lists (missing, failed):
                        * the missing/unknown features
                        * the features for which existence check failed"""
                      missing = []
                      failed = []
                      for line in lines:
                          if line.startswith(TTest.SKIPPED_PREFIX):
                              line = line.splitlines()[0]
                              missing.append(_bytes2sys(line[len(TTest.SKIPPED_PREFIX) :]))
                          elif line.startswith(TTest.FAILED_PREFIX):
                              line = line.splitlines()[0]
                              failed.append(_bytes2sys(line[len(TTest.FAILED_PREFIX) :]))
                      return missing, failed
                  @staticmethod
                  def _escapef(m):
                      return TTest.ESCAPEMAP[m.group(0)]
                  @staticmethod
                  def _stringescape(s):
                      return TTest.ESCAPESUB(TTest._escapef, s)
              iolock = threading.RLock()
              firstlock = threading.RLock()
              firsterror = False
              base_class = unittest.TextTestResult
              class TestResult(base_class):
                  """Holds results when executing via unittest."""
                  def __init__(self, options, *args, **kwargs):
                      super(TestResult, self).__init__(*args, **kwargs)
                      self._options = options
                      # unittest.TestResult didn't have skipped until 2.7. We need to
                      # polyfill it.
                      self.skipped = []
                      # We have a custom "ignored" result that isn't present in any Python
                      # unittest implementation. It is very similar to skipped. It may make
                      # sense to map it into skip some day.
                      self.ignored = []
                      self.times = []
                      self._firststarttime = None
                      # Data stored for the benefit of generating xunit reports.
                      self.successes = []
                      self.faildata = {}
                      if options.color == 'auto':
                          isatty = self.stream.isatty()
                          # For some reason, redirecting stdout on Windows disables the ANSI
                          # color processing of stderr, which is what is used to print the
                          # output.  Therefore, both must be tty on Windows to enable color.
                          if WINDOWS:
                              isatty = isatty and sys.stdout.isatty()
                          self.color = pygmentspresent and isatty
                      elif options.color == 'never':
                          self.color = False
                      else:  # 'always', for testing purposes
                          self.color = pygmentspresent
                  def onStart(self, test):
                      """Can be overriden by custom TestResult"""
                  def onEnd(self):
                      """Can be overriden by custom TestResult"""
                  def addFailure(self, test, reason):
                      self.failures.append((test, reason))
                      if self._options.first:
                          self.stop()
                      else:
                          with iolock:
                              if reason == "timed out":
                                  self.stream.write('t')
                              else:
                                  if not self._options.nodiff:
                                      self.stream.write('\n')
                                      # Exclude the '\n' from highlighting to lex correctly
                                      formatted = 'ERROR: %s output changed\n' % test
                                      self.stream.write(highlightmsg(formatted, self.color))
                                  self.stream.write('!')
                              self.stream.flush()
                  def addSuccess(self, test):
                      with iolock:
                          super(TestResult, self).addSuccess(test)
                      self.successes.append(test)
                  def addError(self, test, err):
                      super(TestResult, self).addError(test, err)
                      if self._options.first:
                          self.stop()
                  # Polyfill.
                  def addSkip(self, test, reason):
                      self.skipped.append((test, reason))
                      with iolock:
                          if self.showAll:
                              self.stream.writeln('skipped %s' % reason)
                          else:
                              self.stream.write('s')
                              self.stream.flush()
                  def addIgnore(self, test, reason):
                      self.ignored.append((test, reason))
                      with iolock:
                          if self.showAll:
                              self.stream.writeln('ignored %s' % reason)
                          else:
                              if reason not in ('not retesting', "doesn't match keyword"):
                                  self.stream.write('i')
                              else:
                                  self.testsRun += 1
                              self.stream.flush()
                  def addOutputMismatch(self, test, ret, got, expected):
                      """Record a mismatch in test output for a particular test."""
                      if self.shouldStop or firsterror:
                          # don't print, some other test case already failed and
                          # printed, we're just stale and probably failed due to our
                          # temp dir getting cleaned up.
                          return
                      accepted = False
                      lines = []
                      with iolock:
                          if self._options.nodiff:
                              pass
                          elif self._options.view:
                              v = self._options.view
                              subprocess.call(
                                  r'"%s" "%s" "%s"'
                                  % (v, _bytes2sys(test.refpath), _bytes2sys(test.errpath)),
                                  shell=True,
                              )
                          else:
                              servefail, lines = getdiff(
                                  expected, got, test.refpath, test.errpath
                              )
                              self.stream.write('\n')
                              for line in lines:
                                  line = highlightdiff(line, self.color)
                                  self.stream.flush()
                                  self.stream.buffer.write(line)
                                  self.stream.buffer.flush()
                              if servefail:
                                  raise test.failureException(
                                      'server failed to start (HGPORT=%s)' % test._startport
                                  )
                          # handle interactive prompt without releasing iolock
                          if self._options.interactive:
                              if test.readrefout() != expected:
                                  self.stream.write(
                                      'Reference output has changed (run again to prompt '
                                      'changes)'
                                  )
                              else:
                                  self.stream.write('Accept this change? [y/N] ')
                                  self.stream.flush()
                                  answer = sys.stdin.readline().strip()
                                  if answer.lower() in ('y', 'yes'):
                                      if test.path.endswith(b'.t'):
                                          rename(test.errpath, test.path)
                                      else:
                                          rename(test.errpath, b'%s.out' % test.path)
                                      accepted = True
                          if not accepted:
                              self.faildata[test.name] = b''.join(lines)
                      return accepted
                  def startTest(self, test):
                      super(TestResult, self).startTest(test)
                      # os.times module computes the user time and system time spent by
                      # child's processes along with real elapsed time taken by a process.
                      # This module has one limitation. It can only work for Linux user
                      # and not for Windows. Hence why we fall back to another function
                      # for wall time calculations.
                      test.started_times = os.times()
                      # TODO use a monotonic clock once support for Python 2.7 is dropped.
                      test.started_time = time.time()
                      if self._firststarttime is None:  # thread racy but irrelevant
                          self._firststarttime = test.started_time
                  def stopTest(self, test, interrupted=False):
                      super(TestResult, self).stopTest(test)
                      test.stopped_times = os.times()
                      stopped_time = time.time()
                      starttime = test.started_times
                      endtime = test.stopped_times
                      origin = self._firststarttime
                      self.times.append(
                          (
                              test.name,
                              endtime[2] - starttime[2],  # user space CPU time
                              endtime[3] - starttime[3],  # sys  space CPU time
                              stopped_time - test.started_time,  # real time
                              test.started_time - origin,  # start date in run context
                              stopped_time - origin,  # end date in run context
                          )
                      )
                      if interrupted:
                          with iolock:
                              self.stream.writeln(
                                  'INTERRUPTED: %s (after %d seconds)'
                                  % (test.name, self.times[-1][3])
                              )
              def getTestResult():
                  """
                  Returns the relevant test result
                  """
                  if "CUSTOM_TEST_RESULT" in os.environ:
                      testresultmodule = __import__(os.environ["CUSTOM_TEST_RESULT"])
                      return testresultmodule.TestResult
                  else:
                      return TestResult
              class TestSuite(unittest.TestSuite):
                  """Custom unittest TestSuite that knows how to execute Mercurial tests."""
                  def __init__(
                      self,
                      testdir,
                      jobs=1,
                      whitelist=None,
                      blacklist=None,
                      keywords=None,
                      loop=False,
                      runs_per_test=1,
                      loadtest=None,
                      showchannels=False,
                      *args,
                      **kwargs
                  ):
                      """Create a new instance that can run tests with a configuration.
                      testdir specifies the directory where tests are executed from. This
                      is typically the ``tests`` directory from Mercurial's source
                      repository.
                      jobs specifies the number of jobs to run concurrently. Each test
                      executes on its own thread. Tests actually spawn new processes, so
                      state mutation should not be an issue.
                      If there is only one job, it will use the main thread.
                      whitelist and blacklist denote tests that have been whitelisted and
                      blacklisted, respectively. These arguments don't belong in TestSuite.
                      Instead, whitelist and blacklist should be handled by the thing that
                      populates the TestSuite with tests. They are present to preserve
                      backwards compatible behavior which reports skipped tests as part
                      of the results.
                      keywords denotes key words that will be used to filter which tests
                      to execute. This arguably belongs outside of TestSuite.
                      loop denotes whether to loop over tests forever.
                      """
                      super(TestSuite, self).__init__(*args, **kwargs)
                      self._jobs = jobs
                      self._whitelist = whitelist
                      self._blacklist = blacklist
                      self._keywords = keywords
                      self._loop = loop
                      self._runs_per_test = runs_per_test
                      self._loadtest = loadtest
                      self._showchannels = showchannels
                  def run(self, result):
                      # We have a number of filters that need to be applied. We do this
                      # here instead of inside Test because it makes the running logic for
                      # Test simpler.
                      tests = []
                      num_tests = [0]
                      for test in self._tests:
                          def get():
                              num_tests[0] += 1
                              if getattr(test, 'should_reload', False):
                                  return self._loadtest(test, num_tests[0])
                              return test
                          if not os.path.exists(test.path):
                              result.addSkip(test, "Doesn't exist")
                              continue
                          is_whitelisted = self._whitelist and (
                              test.relpath in self._whitelist or test.bname in self._whitelist
                          )
                          if not is_whitelisted:
                              is_blacklisted = self._blacklist and (
                                  test.relpath in self._blacklist
                                  or test.bname in self._blacklist
                              )
                              if is_blacklisted:
                                  result.addSkip(test, 'blacklisted')
                                  continue
                              if self._keywords:
                                  with open(test.path, 'rb') as f:
                                      t = f.read().lower() + test.bname.lower()
                                  ignored = False
                                  for k in self._keywords.lower().split():
                                      if k not in t:
                                          result.addIgnore(test, "doesn't match keyword")
                                          ignored = True
                                          break
                                  if ignored:
                                      continue
                          for _ in range(self._runs_per_test):
                              tests.append(get())
                      runtests = list(tests)
                      done = queue.Queue()
                      running = 0
                      channels_lock = threading.Lock()
                      channels = [""] * self._jobs
                      def job(test, result):
                          with channels_lock:
                              for n, v in enumerate(channels):
                                  if not v:
                                      channel = n
                                      break
                              else:
                                  raise ValueError('Could not find output channel')
                              channels[channel] = "=" + test.name[5:].split(".")[0]
                          r = None
                          try:
                              test(result)
                          except KeyboardInterrupt:
                              pass
                          except:  # re-raises
                              r = ('!', test, 'run-test raised an error, see traceback')
                              raise
                          finally:
                              try:
                                  channels[channel] = ''
                              except IndexError:
                                  pass
                              done.put(r)
                      def stat():
                          count = 0
                          while channels:
                              d = '\n%03s  ' % count
                              for n, v in enumerate(channels):
                                  if v:
                                      d += v[0]
                                      channels[n] = v[1:] or '.'
                                  else:
                                      d += ' '
                                  d += ' '
                              with iolock:
                                  sys.stdout.write(d + '  ')
                                  sys.stdout.flush()
                              for x in range(10):
                                  if channels:
                                      time.sleep(0.1)
                              count += 1
                      stoppedearly = False
                      if self._showchannels:
                          statthread = threading.Thread(target=stat, name="stat")
                          statthread.start()
                      try:
                          while tests or running:
                              if not done.empty() or running == self._jobs or not tests:
                                  try:
                                      done.get(True, 1)
                                      running -= 1
                                      if result and result.shouldStop:
                                          stoppedearly = True
                                          break
                                  except queue.Empty:
                                      continue
                              if tests and not running == self._jobs:
                                  test = tests.pop(0)
                                  if self._loop:
                                      if getattr(test, 'should_reload', False):
                                          num_tests[0] += 1
                                          tests.append(self._loadtest(test, num_tests[0]))
                                      else:
                                          tests.append(test)
                                  if self._jobs == 1:
                                      job(test, result)
                                  else:
                                      t = threading.Thread(
                                          target=job, name=test.name, args=(test, result)
                                      )
                                      t.start()
                                  running += 1
                          # If we stop early we still need to wait on started tests to
                          # finish. Otherwise, there is a race between the test completing
                          # and the test's cleanup code running. This could result in the
                          # test reporting incorrect.
                          if stoppedearly:
                              while running:
                                  try:
                                      done.get(True, 1)
                                      running -= 1
                                  except queue.Empty:
                                      continue
                      except KeyboardInterrupt:
                          for test in runtests:
                              test.abort()
                      channels = []
                      return result
              # Save the most recent 5 wall-clock runtimes of each test to a
              # human-readable text file named .testtimes. Tests are sorted
              # alphabetically, while times for each test are listed from oldest to
              # newest.
              def loadtimes(outputdir):
                  times = []
                  try:
                      with open(os.path.join(outputdir, b'.testtimes')) as fp:
                          for line in fp:
                              m = re.match('(.*?) ([0-9. ]+)', line)
                              times.append(
                                  (m.group(1), [float(t) for t in m.group(2).split()])
                              )
                  except FileNotFoundError:
                      pass
                  return times
              def savetimes(outputdir, result):
                  saved = dict(loadtimes(outputdir))
                  maxruns = 5
                  skipped = {str(t[0]) for t in result.skipped}
                  for tdata in result.times:
                      test, real = tdata[0], tdata[3]
                      if test not in skipped:
                          ts = saved.setdefault(test, [])
                          ts.append(real)
                          ts[:] = ts[-maxruns:]
                  fd, tmpname = tempfile.mkstemp(
                      prefix=b'.testtimes', dir=outputdir, text=True
                  )
                  with os.fdopen(fd, 'w') as fp:
                      for name, ts in sorted(saved.items()):
                          fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts])))
                  timepath = os.path.join(outputdir, b'.testtimes')
                  try:
                      os.unlink(timepath)
                  except OSError:
                      pass
                  try:
                      os.rename(tmpname, timepath)
                  except OSError:
                      pass
              class TextTestRunner(unittest.TextTestRunner):
                  """Custom unittest test runner that uses appropriate settings."""
                  def __init__(self, runner, *args, **kwargs):
                      super(TextTestRunner, self).__init__(*args, **kwargs)
                      self._runner = runner
                      self._result = getTestResult()(
                          self._runner.options, self.stream, self.descriptions, self.verbosity
                      )
                  def listtests(self, test):
                      test = sorted(test, key=lambda t: t.name)
                      self._result.onStart(test)
                      for t in test:
                          print(t.name)
                          self._result.addSuccess(t)
                      if self._runner.options.xunit:
                          with open(self._runner.options.xunit, "wb") as xuf:
                              self._writexunit(self._result, xuf)
                      if self._runner.options.json:
                          jsonpath = os.path.join(self._runner._outputdir, b'report.json')
                          with open(jsonpath, 'w') as fp:
                              self._writejson(self._result, fp)
                      return self._result
                  def run(self, test):
                      self._result.onStart(test)
                      test(self._result)
                      failed = len(self._result.failures)
                      skipped = len(self._result.skipped)
                      ignored = len(self._result.ignored)
                      with iolock:
                          self.stream.writeln('')
                          if not self._runner.options.noskips:
                              for test, msg in sorted(
                                  self._result.skipped, key=lambda s: s[0].name
                              ):
                                  formatted = 'Skipped %s: %s\n' % (test.name, msg)
                                  msg = highlightmsg(formatted, self._result.color)
                                  self.stream.write(msg)
                          for test, msg in sorted(
                              self._result.failures, key=lambda f: f[0].name
                          ):
                              formatted = 'Failed %s: %s\n' % (test.name, msg)
                              self.stream.write(highlightmsg(formatted, self._result.color))
                          for test, msg in sorted(
                              self._result.errors, key=lambda e: e[0].name
                          ):
                              self.stream.writeln('Errored %s: %s' % (test.name, msg))
                          if self._runner.options.xunit:
                              with open(self._runner.options.xunit, "wb") as xuf:
                                  self._writexunit(self._result, xuf)
                          if self._runner.options.json:
                              jsonpath = os.path.join(self._runner._outputdir, b'report.json')
                              with open(jsonpath, 'w') as fp:
                                  self._writejson(self._result, fp)
                          self._runner._checkhglib('Tested')
                          savetimes(self._runner._outputdir, self._result)
                          if failed and self._runner.options.known_good_rev:
                              self._bisecttests(t for t, m in self._result.failures)
                          self.stream.writeln(
                              '# Ran %d tests, %d skipped, %d failed.'
                              % (self._result.testsRun, skipped + ignored, failed)
                          )
                          if failed:
                              self.stream.writeln(
                                  'python hash seed: %s' % os.environ['PYTHONHASHSEED']
                              )
                          if self._runner.options.time:
                              self.printtimes(self._result.times)
                          if self._runner.options.exceptions:
                              exceptions = aggregateexceptions(
                                  os.path.join(self._runner._outputdir, b'exceptions')
                              )
                              self.stream.writeln('Exceptions Report:')
                              self.stream.writeln(
                                  '%d total from %d frames'
                                  % (exceptions['total'], len(exceptions['exceptioncounts']))
                              )
                              combined = exceptions['combined']
                              for key in sorted(combined, key=combined.get, reverse=True):
                                  frame, line, exc = key
                                  totalcount, testcount, leastcount, leasttest = combined[key]
                                  self.stream.writeln(
                                      '%d (%d tests)\t%s: %s (%s - %d total)'
                                      % (
                                          totalcount,
                                          testcount,
                                          frame,
                                          exc,
                                          leasttest,
                                          leastcount,
                                      )
                                  )
                          self.stream.flush()
                      return self._result
                  def _bisecttests(self, tests):
                      bisectcmd = ['hg', 'bisect']
                      bisectrepo = self._runner.options.bisect_repo
                      if bisectrepo:
                          bisectcmd.extend(['-R', os.path.abspath(bisectrepo)])
                      def pread(args):
                          env = os.environ.copy()
                          env['HGPLAIN'] = '1'
                          p = subprocess.Popen(
                              args, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, env=env
                          )
                          data = p.stdout.read()
                          p.wait()
                          return data
                      for test in tests:
                          pread(bisectcmd + ['--reset']),
                          pread(bisectcmd + ['--bad', '.'])
                          pread(bisectcmd + ['--good', self._runner.options.known_good_rev])
                          # TODO: we probably need to forward more options
                          # that alter hg's behavior inside the tests.
                          opts = ''
                          withhg = self._runner.options.with_hg
                          if withhg:
                              opts += ' --with-hg=%s ' % shellquote(_bytes2sys(withhg))
                          rtc = '%s %s %s %s' % (sysexecutable, sys.argv[0], opts, test)
                          data = pread(bisectcmd + ['--command', rtc])
                          m = re.search(
                              (
                                  br'\nThe first (?P<goodbad>bad|good) revision '
                                  br'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n'
                                  br'summary: +(?P<summary>[^\n]+)\n'
                              ),
                              data,
                              (re.MULTILINE | re.DOTALL),
                          )
                          if m is None:
                              self.stream.writeln(
                                  'Failed to identify failure point for %s' % test
                              )
                              continue
                          dat = m.groupdict()
                          verb = 'broken' if dat['goodbad'] == b'bad' else 'fixed'
                          self.stream.writeln(
                              '%s %s by %s (%s)'
                              % (
                                  test,
                                  verb,
                                  dat['node'].decode('ascii'),
                                  dat['summary'].decode('utf8', 'ignore'),
                              )
                          )
                  def printtimes(self, times):
                      # iolock held by run
                      self.stream.writeln('# Producing time report')
                      times.sort(key=lambda t: (t[3]))
                      cols = '%7.3f %7.3f %7.3f %7.3f %7.3f   %s'
                      self.stream.writeln(
                          '%-7s %-7s %-7s %-7s %-7s   %s'
                          % ('start', 'end', 'cuser', 'csys', 'real', 'Test')
                      )
                      for tdata in times:
                          test = tdata[0]
                          cuser, csys, real, start, end = tdata[1:6]
                          self.stream.writeln(cols % (start, end, cuser, csys, real, test))
                  @staticmethod
                  def _writexunit(result, outf):
                      # See http://llg.cubic.org/docs/junit/ for a reference.
                      timesd = {t[0]: t[3] for t in result.times}
                      doc = minidom.Document()
                      s = doc.createElement('testsuite')
                      s.setAttribute('errors', "0")  # TODO
                      s.setAttribute('failures', str(len(result.failures)))
                      s.setAttribute('name', 'run-tests')
                      s.setAttribute(
                          'skipped', str(len(result.skipped) + len(result.ignored))
                      )
                      s.setAttribute('tests', str(result.testsRun))
                      doc.appendChild(s)
                      for tc in result.successes:
                          t = doc.createElement('testcase')
                          t.setAttribute('name', tc.name)
                          tctime = timesd.get(tc.name)
                          if tctime is not None:
                              t.setAttribute('time', '%.3f' % tctime)
                          s.appendChild(t)
                      for tc, err in sorted(result.faildata.items()):
                          t = doc.createElement('testcase')
                          t.setAttribute('name', tc)
                          tctime = timesd.get(tc)
                          if tctime is not None:
                              t.setAttribute('time', '%.3f' % tctime)
                          # createCDATASection expects a unicode or it will
                          # convert using default conversion rules, which will
                          # fail if string isn't ASCII.
                          err = cdatasafe(err).decode('utf-8', 'replace')
                          cd = doc.createCDATASection(err)
                          # Use 'failure' here instead of 'error' to match errors = 0,
                          # failures = len(result.failures) in the testsuite element.
                          failelem = doc.createElement('failure')
                          failelem.setAttribute('message', 'output changed')
                          failelem.setAttribute('type', 'output-mismatch')
                          failelem.appendChild(cd)
                          t.appendChild(failelem)
                          s.appendChild(t)
                      for tc, message in result.skipped:
                          # According to the schema, 'skipped' has no attributes. So store
                          # the skip message as a text node instead.
                          t = doc.createElement('testcase')
                          t.setAttribute('name', tc.name)
                          binmessage = message.encode('utf-8')
                          message = cdatasafe(binmessage).decode('utf-8', 'replace')
                          cd = doc.createCDATASection(message)
                          skipelem = doc.createElement('skipped')
                          skipelem.appendChild(cd)
                          t.appendChild(skipelem)
                          s.appendChild(t)
                      outf.write(doc.toprettyxml(indent='  ', encoding='utf-8'))
                  @staticmethod
                  def _writejson(result, outf):
                      timesd = {}
                      for tdata in result.times:
                          test = tdata[0]
                          timesd[test] = tdata[1:]
                      outcome = {}
                      groups = [
                          ('success', ((tc, None) for tc in result.successes)),
                          ('failure', result.failures),
                          ('skip', result.skipped),
                      ]
                      for res, testcases in groups:
                          for tc, __ in testcases:
                              if tc.name in timesd:
                                  diff = result.faildata.get(tc.name, b'')
                                  try:
                                      diff = diff.decode('unicode_escape')
                                  except UnicodeDecodeError as e:
                                      diff = '%r decoding diff, sorry' % e
                                  tres = {
                                      'result': res,
                                      'time': ('%0.3f' % timesd[tc.name][2]),
                                      'cuser': ('%0.3f' % timesd[tc.name][0]),
                                      'csys': ('%0.3f' % timesd[tc.name][1]),
                                      'start': ('%0.3f' % timesd[tc.name][3]),
                                      'end': ('%0.3f' % timesd[tc.name][4]),
                                      'diff': diff,
                                  }
                              else:
                                  # blacklisted test
                                  tres = {'result': res}
                              outcome[tc.name] = tres
                      jsonout = json.dumps(
                          outcome, sort_keys=True, indent=4, separators=(',', ': ')
                      )
                      outf.writelines(("testreport =", jsonout))
              def sorttests(testdescs, previoustimes, shuffle=False):
                  """Do an in-place sort of tests."""
                  if shuffle:
                      random.shuffle(testdescs)
                      return
                  if previoustimes:
                      def sortkey(f):
                          f = f['path']
                          if f in previoustimes:
                              # Use most recent time as estimate
                              return -(previoustimes[f][-1])
                          else:
                              # Default to a rather arbitrary value of 1 second for new tests
                              return -1.0
                  else:
                      # keywords for slow tests
                      slow = {
                          b'svn': 10,
                          b'cvs': 10,
                          b'hghave': 10,
                          b'largefiles-update': 10,
                          b'run-tests': 10,
                          b'corruption': 10,
                          b'race': 10,
                          b'i18n': 10,
                          b'check': 100,
                          b'gendoc': 100,
                          b'contrib-perf': 200,
                          b'merge-combination': 100,
                      }
                      perf = {}
                      def sortkey(f):
                          # run largest tests first, as they tend to take the longest
                          f = f['path']
                          try:
                              return perf[f]
                          except KeyError:
                              try:
                                  val = -os.stat(f).st_size
                              except FileNotFoundError:
                                  perf[f] = -1e9  # file does not exist, tell early
                                  return -1e9
                              for kw, mul in slow.items():
                                  if kw in f:
                                      val *= mul
                              if f.endswith(b'.py'):
                                  val /= 10.0
                              perf[f] = val / 1000.0
                              return perf[f]
                  testdescs.sort(key=sortkey)
              class TestRunner:
                  """Holds context for executing tests.
                  Tests rely on a lot of state. This object holds it for them.
                  """
                  # Programs required to run tests.
                  REQUIREDTOOLS = [
                      b'diff',
                      b'grep',
                      b'unzip',
                      b'gunzip',
                      b'bunzip2',
                      b'sed',
                  ]
                  # Maps file extensions to test class.
                  TESTTYPES = [
                      (b'.py', PythonTest),
                      (b'.t', TTest),
                  ]
                  def __init__(self):
                      self.options = None
                      self._hgroot = None
                      self._testdir = None
                      self._outputdir = None
                      self._hgtmp = None
                      self._installdir = None
                      self._bindir = None
                      # a place for run-tests.py to generate executable it needs
                      self._custom_bin_dir = None
                      self._pythondir = None
                      # True if we had to infer the pythondir from --with-hg
                      self._pythondir_inferred = False
                      self._coveragefile = None
                      self._createdfiles = []
                      self._hgcommand = None
                      self._hgpath = None
                      self._portoffset = 0
                      self._ports = {}
                  def run(self, args, parser=None):
                      """Run the test suite."""
                      oldmask = os.umask(0o22)
                      try:
                          parser = parser or getparser()
                          options = parseargs(args, parser)
                          tests = [_sys2bytes(a) for a in options.tests]
                          if options.test_list is not None:
                              for listfile in options.test_list:
                                  with open(listfile, 'rb') as f:
                                      tests.extend(t for t in f.read().splitlines() if t)
                          self.options = options
                          self._checktools()
                          testdescs = self.findtests(tests)
                          if options.profile_runner:
                              import statprof
                              statprof.start()
                          result = self._run(testdescs)
                          if options.profile_runner:
                              statprof.stop()
                              statprof.display()
                          return result
                      finally:
                          os.umask(oldmask)
                  def _run(self, testdescs):
                      testdir = getcwdb()
                      # assume all tests in same folder for now
                      if testdescs:
                          pathname = os.path.dirname(testdescs[0]['path'])
                          if pathname:
                              testdir = os.path.join(testdir, pathname)
                      self._testdir = osenvironb[b'TESTDIR'] = testdir
                      osenvironb[b'TESTDIR_FORWARD_SLASH'] = osenvironb[b'TESTDIR'].replace(
                          os.sep.encode('ascii'), b'/'
                      )
                      if self.options.outputdir:
                          self._outputdir = canonpath(_sys2bytes(self.options.outputdir))
                      else:
                          self._outputdir = getcwdb()
                          if testdescs and pathname:
                              self._outputdir = os.path.join(self._outputdir, pathname)
                      previoustimes = {}
                      if self.options.order_by_runtime:
                          previoustimes = dict(loadtimes(self._outputdir))
                      sorttests(testdescs, previoustimes, shuffle=self.options.random)
                      if 'PYTHONHASHSEED' not in os.environ:
                          # use a random python hash seed all the time
                          # we do the randomness ourself to know what seed is used
                          os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32))
                      # Rayon (Rust crate for multi-threading) will use all logical CPU cores
                      # by default, causing thrashing on high-cpu-count systems.
                      # Setting its limit to 3 during tests should still let us uncover
                      # multi-threading bugs while keeping the thrashing reasonable.
                      os.environ.setdefault("RAYON_NUM_THREADS", "3")
                      if self.options.tmpdir:
                          self.options.keep_tmpdir = True
                          tmpdir = _sys2bytes(self.options.tmpdir)
                          if os.path.exists(tmpdir):
                              # Meaning of tmpdir has changed since 1.3: we used to create
                              # HGTMP inside tmpdir; now HGTMP is tmpdir.  So fail if
                              # tmpdir already exists.
                              print("error: temp dir %r already exists" % tmpdir)
                              return 1
                          os.makedirs(tmpdir)
                      else:
                          d = None
                          if WINDOWS:
                              # without this, we get the default temp dir location, but
                              # in all lowercase, which causes troubles with paths (issue3490)
                              d = osenvironb.get(b'TMP', None)
                          tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d)
                      self._hgtmp = osenvironb[b'HGTMP'] = os.path.realpath(tmpdir)
                      self._custom_bin_dir = os.path.join(self._hgtmp, b'custom-bin')
                      os.makedirs(self._custom_bin_dir)
                      # detect and enforce an alternative way to specify rust extension usage
                      if (
                          not (self.options.pure or self.options.rust or self.options.no_rust)
                          and os.environ.get("HGWITHRUSTEXT") == "cpython"
                      ):
                          self.options.rust = True
                      if self.options.with_hg:
                          self._installdir = None
                          whg = self.options.with_hg
                          self._bindir = os.path.dirname(os.path.realpath(whg))
                          assert isinstance(self._bindir, bytes)
                          self._hgcommand = os.path.basename(whg)
                          normbin = os.path.normpath(os.path.abspath(whg))
                          normbin = normbin.replace(_sys2bytes(os.sep), b'/')
                          # Other Python scripts in the test harness need to
                          # `import mercurial`. If `hg` is a Python script, we assume
                          # the Mercurial modules are relative to its path and tell the tests
                          # to load Python modules from its directory.
                          with open(whg, 'rb') as fh:
                              initial = fh.read(1024)
                          if re.match(b'#!.*python', initial):
                              self._pythondir = self._bindir
                          # If it looks like our in-repo Rust binary, use the source root.
                          # This is a bit hacky. But rhg is still not supported outside the
                          # source directory. So until it is, do the simple thing.
                          elif re.search(b'/rust/target/[^/]+/hg', normbin):
                              self._pythondir = os.path.dirname(self._testdir)
                          # Fall back to the legacy behavior.
                          else:
                              self._pythondir = self._bindir
                          self._pythondir_inferred = True
                      else:
                          self._installdir = os.path.join(self._hgtmp, b"install")
                          self._bindir = os.path.join(self._installdir, b"bin")
                          self._hgcommand = b'hg'
                          self._pythondir = os.path.join(self._installdir, b"lib", b"python")
                      # Force the use of hg.exe instead of relying on MSYS to recognize hg is
                      # a python script and feed it to python.exe.  Legacy stdio is force
                      # enabled by hg.exe, and this is a more realistic way to launch hg
                      # anyway.
                      if WINDOWS and not self._hgcommand.endswith(b'.exe'):
                          self._hgcommand += b'.exe'
                      real_hg = os.path.join(self._bindir, self._hgcommand)
                      osenvironb[b'HGTEST_REAL_HG'] = real_hg
                      # set CHGHG, then replace "hg" command by "chg"
                      chgbindir = self._bindir
                      if self.options.chg or self.options.with_chg:
                          osenvironb[b'CHG_INSTALLED_AS_HG'] = b'1'
                          osenvironb[b'CHGHG'] = real_hg
                      else:
                          # drop flag for hghave
                          osenvironb.pop(b'CHG_INSTALLED_AS_HG', None)
                      if self.options.chg:
                          self._hgcommand = b'chg'
                      elif self.options.with_chg:
                          chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg))
                          self._hgcommand = os.path.basename(self.options.with_chg)
                      # configure fallback and replace "hg" command by "rhg"
                      rhgbindir = self._bindir
                      if self.options.rhg or self.options.with_rhg:
                          # Affects hghave.py
                          osenvironb[b'RHG_INSTALLED_AS_HG'] = b'1'
                          # Affects configuration. Alternatives would be setting configuration through
                          # `$HGRCPATH` but some tests override that, or changing `_hgcommand` to include
                          # `--config` but that disrupts tests that print command lines and check expected
                          # output.
                          osenvironb[b'RHG_ON_UNSUPPORTED'] = b'fallback'
                          osenvironb[b'RHG_FALLBACK_EXECUTABLE'] = real_hg
                      else:
                          # drop flag for hghave
                          osenvironb.pop(b'RHG_INSTALLED_AS_HG', None)
                      if self.options.rhg:
                          self._hgcommand = b'rhg'
                      elif self.options.with_rhg:
                          rhgbindir = os.path.dirname(os.path.realpath(self.options.with_rhg))
                          self._hgcommand = os.path.basename(self.options.with_rhg)
                      if self.options.pyoxidized:
                          testdir = os.path.dirname(_sys2bytes(canonpath(sys.argv[0])))
                          reporootdir = os.path.dirname(testdir)
                          # XXX we should ideally install stuff instead of using the local build
                          exe = b'hg'
                          triple = b''
                          if WINDOWS:
                              triple = b'x86_64-pc-windows-msvc'
                              exe = b'hg.exe'
                          elif MACOS:
                              # TODO: support Apple silicon too
                              triple = b'x86_64-apple-darwin'
                          bin_path = b'build/pyoxidizer/%s/release/app/%s' % (triple, exe)
                          full_path = os.path.join(reporootdir, bin_path)
                          self._hgcommand = full_path
                          # Affects hghave.py
                          osenvironb[b'PYOXIDIZED_INSTALLED_AS_HG'] = b'1'
                      else:
                          osenvironb.pop(b'PYOXIDIZED_INSTALLED_AS_HG', None)
                      osenvironb[b"BINDIR"] = self._bindir
                      osenvironb[b"PYTHON"] = PYTHON
                      fileb = _sys2bytes(__file__)
                      runtestdir = os.path.abspath(os.path.dirname(fileb))
                      osenvironb[b'RUNTESTDIR'] = runtestdir
                      osenvironb[b'RUNTESTDIR_FORWARD_SLASH'] = runtestdir.replace(
                          os.sep.encode('ascii'), b'/'
                      )
                      sepb = _sys2bytes(os.pathsep)
                      path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb)
                      if os.path.islink(__file__):
                          # test helper will likely be at the end of the symlink
                          realfile = os.path.realpath(fileb)
                          realdir = os.path.abspath(os.path.dirname(realfile))
                          path.insert(2, realdir)
                      if chgbindir != self._bindir:
                          path.insert(1, chgbindir)
                      if rhgbindir != self._bindir:
                          path.insert(1, rhgbindir)
                      if self._testdir != runtestdir:
                          path = [self._testdir] + path
                      path = [self._custom_bin_dir] + path
                      osenvironb[b"PATH"] = sepb.join(path)
                      # Include TESTDIR in PYTHONPATH so that out-of-tree extensions
                      # can run .../tests/run-tests.py test-foo where test-foo
                      # adds an extension to HGRC. Also include run-test.py directory to
                      # import modules like heredoctest.
                      pypath = [self._pythondir, self._testdir, runtestdir]
                      # Setting PYTHONPATH with an activated venv causes the modules installed
                      # in it to be ignored.  Therefore, include the related paths in sys.path
                      # in PYTHONPATH.
                      virtual_env = osenvironb.get(b"VIRTUAL_ENV")
                      if virtual_env:
                          virtual_env = os.path.join(virtual_env, b'')
                          for p in sys.path:
                              p = _sys2bytes(p)
                              if p.startswith(virtual_env):
                                  pypath.append(p)
                      # We have to augment PYTHONPATH, rather than simply replacing
                      # it, in case external libraries are only available via current
                      # PYTHONPATH.  (In particular, the Subversion bindings on OS X
                      # are in /opt/subversion.)
                      oldpypath = osenvironb.get(IMPL_PATH)
                      if oldpypath:
                          pypath.append(oldpypath)
                      osenvironb[IMPL_PATH] = sepb.join(pypath)
                      if self.options.pure:
                          os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure"
                          os.environ["HGMODULEPOLICY"] = "py"
                      if self.options.rust:
                          os.environ["HGMODULEPOLICY"] = "rust+c"
                      if self.options.no_rust:
                          current_policy = os.environ.get("HGMODULEPOLICY", "")
                          if current_policy.startswith("rust+"):
                              os.environ["HGMODULEPOLICY"] = current_policy[len("rust+") :]
                          os.environ.pop("HGWITHRUSTEXT", None)
                      if self.options.allow_slow_tests:
                          os.environ["HGTEST_SLOW"] = "slow"
                      elif 'HGTEST_SLOW' in os.environ:
                          del os.environ['HGTEST_SLOW']
                      self._coveragefile = os.path.join(self._testdir, b'.coverage')
                      if self.options.exceptions:
                          exceptionsdir = os.path.join(self._outputdir, b'exceptions')
                          try:
                              os.makedirs(exceptionsdir)
                          except FileExistsError:
                              pass
                          # Remove all existing exception reports.
                          for f in os.listdir(exceptionsdir):
                              os.unlink(os.path.join(exceptionsdir, f))
                          osenvironb[b'HGEXCEPTIONSDIR'] = exceptionsdir
                          logexceptions = os.path.join(self._testdir, b'logexceptions.py')
                          self.options.extra_config_opt.append(
                              'extensions.logexceptions=%s' % logexceptions.decode('utf-8')
                          )
                      vlog("# Using TESTDIR", _bytes2sys(self._testdir))
                      vlog("# Using RUNTESTDIR", _bytes2sys(osenvironb[b'RUNTESTDIR']))
                      vlog("# Using HGTMP", _bytes2sys(self._hgtmp))
                      vlog("# Using PATH", os.environ["PATH"])
                      vlog(
                          "# Using",
                          _bytes2sys(IMPL_PATH),
                          _bytes2sys(osenvironb[IMPL_PATH]),
                      )
                      vlog("# Writing to directory", _bytes2sys(self._outputdir))
                      try:
                          return self._runtests(testdescs) or 0
                      finally:
                          time.sleep(0.1)
                          self._cleanup()
                  def findtests(self, args):
                      """Finds possible test files from arguments.
                      If you wish to inject custom tests into the test harness, this would
                      be a good function to monkeypatch or override in a derived class.
                      """
                      if not args:
                          if self.options.changed:
                              proc = Popen4(
                                  b'hg st --rev "%s" -man0 .'
                                  % _sys2bytes(self.options.changed),
                                  None,
 ,
                              )
                              stdout, stderr = proc.communicate()
                              args = stdout.strip(b'\0').split(b'\0')
                          else:
                              args = os.listdir(b'.')
                      expanded_args = []
                      for arg in args:
                          if os.path.isdir(arg):
                              if not arg.endswith(b'/'):
                                  arg += b'/'
                              expanded_args.extend([arg + a for a in os.listdir(arg)])
                          else:
                              expanded_args.append(arg)
                      args = expanded_args
                      testcasepattern = re.compile(br'([\w-]+\.t|py)(?:#([a-zA-Z0-9_\-.#]+))')
                      tests = []
                      for t in args:
                          case = []
                          if not (
                              os.path.basename(t).startswith(b'test-')
                              and (t.endswith(b'.py') or t.endswith(b'.t'))
                          ):
                              m = testcasepattern.match(os.path.basename(t))
                              if m is not None:
                                  t_basename, casestr = m.groups()
                                  t = os.path.join(os.path.dirname(t), t_basename)
                                  if casestr:
                                      case = casestr.split(b'#')
                              else:
                                  continue
                          if t.endswith(b'.t'):
                              # .t file may contain multiple test cases
                              casedimensions = parsettestcases(t)
                              if casedimensions:
                                  cases = []
                                  def addcases(case, casedimensions):
                                      if not casedimensions:
                                          cases.append(case)
                                      else:
                                          for c in casedimensions[0]:
                                              addcases(case + [c], casedimensions[1:])
                                  addcases([], casedimensions)
                                  if case and case in cases:
                                      cases = [case]
                                  elif case:
                                      # Ignore invalid cases
                                      cases = []
                                  else:
                                      pass
                                  tests += [{'path': t, 'case': c} for c in sorted(cases)]
                              else:
                                  tests.append({'path': t})
                          else:
                              tests.append({'path': t})
                      if self.options.retest:
                          retest_args = []
                          for test in tests:
                              errpath = self._geterrpath(test)
                              if os.path.exists(errpath):
                                  retest_args.append(test)
                          tests = retest_args
                      return tests
                  def _runtests(self, testdescs):
                      def _reloadtest(test, i):
                          # convert a test back to its description dict
                          desc = {'path': test.path}
                          case = getattr(test, '_case', [])
                          if case:
                              desc['case'] = case
                          return self._gettest(desc, i)
                      try:
                          if self.options.restart:
                              orig = list(testdescs)
                              while testdescs:
                                  desc = testdescs[0]
                                  errpath = self._geterrpath(desc)
                                  if os.path.exists(errpath):
                                      break
                                  testdescs.pop(0)
                              if not testdescs:
                                  print("running all tests")
                                  testdescs = orig
                          tests = [self._gettest(d, i) for i, d in enumerate(testdescs)]
                          num_tests = len(tests) * self.options.runs_per_test
                          jobs = min(num_tests, self.options.jobs)
                          failed = False
                          kws = self.options.keywords
                          if kws is not None:
                              kws = kws.encode('utf-8')
                          suite = TestSuite(
                              self._testdir,
                              jobs=jobs,
                              whitelist=self.options.whitelisted,
                              blacklist=self.options.blacklist,
                              keywords=kws,
                              loop=self.options.loop,
                              runs_per_test=self.options.runs_per_test,
                              showchannels=self.options.showchannels,
                              tests=tests,
                              loadtest=_reloadtest,
                          )
                          verbosity = 1
                          if self.options.list_tests:
                              verbosity = 0
                          elif self.options.verbose:
                              verbosity = 2
                          runner = TextTestRunner(self, verbosity=verbosity)
                          osenvironb.pop(b'PYOXIDIZED_IN_MEMORY_RSRC', None)
                          osenvironb.pop(b'PYOXIDIZED_FILESYSTEM_RSRC', None)
                          if self.options.list_tests:
                              result = runner.listtests(suite)
                          else:
                              install_start_time = time.monotonic()
                              self._usecorrectpython()
                              if self._installdir:
                                  self._installhg()
                                  self._checkhglib("Testing")
                              if self.options.chg:
                                  assert self._installdir
                                  self._installchg()
                              if self.options.rhg:
                                  assert self._installdir
                                  self._installrhg()
                              elif self.options.pyoxidized:
                                  self._build_pyoxidized()
                              self._use_correct_mercurial()
                              install_end_time = time.monotonic()
                              if self._installdir:
                                  msg = 'installed Mercurial in %.2f seconds'
                                  msg %= install_end_time - install_start_time
                                  log(msg)
                              log(
                                  'running %d tests using %d parallel processes'
                                  % (num_tests, jobs)
                              )
                              result = runner.run(suite)
                          if result.failures or result.errors:
                              failed = True
                          result.onEnd()
                          if self.options.anycoverage:
                              self._outputcoverage()
                      except KeyboardInterrupt:
                          failed = True
                          print("\ninterrupted!")
                      if failed:
                          return 1
                  def _geterrpath(self, test):
                      # test['path'] is a relative path
                      if 'case' in test:
                          # for multiple dimensions test cases
                          casestr = b'#'.join(test['case'])
                          errpath = b'%s#%s.err' % (test['path'], casestr)
                      else:
                          errpath = b'%s.err' % test['path']
                      if self.options.outputdir:
                          self._outputdir = canonpath(_sys2bytes(self.options.outputdir))
                          errpath = os.path.join(self._outputdir, errpath)
                      return errpath
                  def _getport(self, count):
                      port = self._ports.get(count)  # do we have a cached entry?
                      if port is None:
                          portneeded = 3
                          # above 100 tries we just give up and let test reports failure
                          for tries in range(100):
                              allfree = True
                              port = self.options.port + self._portoffset
                              for idx in range(portneeded):
                                  if not checkportisavailable(port + idx):
                                      allfree = False
                                      break
                              self._portoffset += portneeded
                              if allfree:
                                  break
                          self._ports[count] = port
                      return port
                  def _gettest(self, testdesc, count):
                      """Obtain a Test by looking at its filename.
                      Returns a Test instance. The Test may not be runnable if it doesn't
                      map to a known type.
                      """
                      path = testdesc['path']
                      lctest = path.lower()
                      testcls = Test
                      for ext, cls in self.TESTTYPES:
                          if lctest.endswith(ext):
                              testcls = cls
                              break
                      refpath = os.path.join(getcwdb(), path)
                      tmpdir = os.path.join(self._hgtmp, b'child%d' % count)
                      # extra keyword parameters. 'case' is used by .t tests
                      kwds = {k: testdesc[k] for k in ['case'] if k in testdesc}
                      t = testcls(
                          refpath,
                          self._outputdir,
                          tmpdir,
                          keeptmpdir=self.options.keep_tmpdir,
                          debug=self.options.debug,
                          first=self.options.first,
                          timeout=self.options.timeout,
                          startport=self._getport(count),
                          extraconfigopts=self.options.extra_config_opt,
                          shell=self.options.shell,
                          hgcommand=self._hgcommand,
                          usechg=bool(self.options.with_chg or self.options.chg),
                          chgdebug=self.options.chg_debug,
                          useipv6=useipv6,
                          **kwds
                      )
                      t.should_reload = True
                      return t
                  def _cleanup(self):
                      """Clean up state from this test invocation."""
                      if self.options.keep_tmpdir:
                          return
                      vlog("# Cleaning up HGTMP", _bytes2sys(self._hgtmp))
                      shutil.rmtree(self._hgtmp, True)
                      for f in self._createdfiles:
                          try:
                              os.remove(f)
                          except OSError:
                              pass
                  def _usecorrectpython(self):
                      """Configure the environment to use the appropriate Python in tests."""
                      # Tests must use the same interpreter as us or bad things will happen.
                      if WINDOWS:
                          pyexe_names = [b'python', b'python3', b'python.exe']
                      else:
                          pyexe_names = [b'python', b'python3']
                      # os.symlink() is a thing with py3 on Windows, but it requires
                      # Administrator rights.
                      if not WINDOWS and getattr(os, 'symlink', None):
                          msg = "# Making python executable in test path a symlink to '%s'"
                          msg %= sysexecutable
                          vlog(msg)
                          for pyexename in pyexe_names:
                              mypython = os.path.join(self._custom_bin_dir, pyexename)
                              try:
                                  if os.readlink(mypython) == sysexecutable:
                                      continue
                                  os.unlink(mypython)
                              except FileNotFoundError:
                                  pass
                              if self._findprogram(pyexename) != sysexecutable:
                                  try:
                                      os.symlink(sysexecutable, mypython)
                                      self._createdfiles.append(mypython)
                                  except FileExistsError:
                                      # child processes may race, which is harmless
                                      pass
                      elif WINDOWS and not os.getenv('MSYSTEM'):
                          raise AssertionError('cannot run test on Windows without MSYSTEM')
                      else:
                          # Generate explicit file instead of symlink
                          #
                          # This is especially important as Windows doesn't have
                          # `python3.exe`, and MSYS cannot understand the reparse point with
                          # that name provided by Microsoft.  Create a simple script on PATH
                          # with that name that delegates to the py3 launcher so the shebang
                          # lines work.
                          esc_executable = _sys2bytes(shellquote(sysexecutable))
                          for pyexename in pyexe_names:
                              stub_exec_path = os.path.join(self._custom_bin_dir, pyexename)
                              with open(stub_exec_path, 'wb') as f:
                                  f.write(b'#!/bin/sh\n')
                                  f.write(b'%s "$@"\n' % esc_executable)
                          if WINDOWS:
                              # adjust the path to make sur the main python finds it own dll
                              path = os.environ['PATH'].split(os.pathsep)
                              main_exec_dir = os.path.dirname(sysexecutable)
                              extra_paths = [_bytes2sys(self._custom_bin_dir), main_exec_dir]
                              # Binaries installed by pip into the user area like pylint.exe may
                              # not be in PATH by default.
                              appdata = os.environ.get('APPDATA')
                              vi = sys.version_info
                              if appdata is not None:
                                  python_dir = 'Python%d%d' % (vi[0], vi[1])
                                  scripts_path = [appdata, 'Python', python_dir, 'Scripts']
                                  scripts_dir = os.path.join(*scripts_path)
                                  extra_paths.append(scripts_dir)
                              os.environ['PATH'] = os.pathsep.join(extra_paths + path)
                  def _use_correct_mercurial(self):
                      target_exec = os.path.join(self._custom_bin_dir, b'hg')
                      if self._hgcommand != b'hg':
                          # shutil.which only accept bytes from 3.8
                          real_exec = which(self._hgcommand)
                          if real_exec is None:
                              raise ValueError('could not find exec path for "%s"', real_exec)
                          if real_exec == target_exec:
                              # do not overwrite something with itself
                              return
                          if WINDOWS:
                              with open(target_exec, 'wb') as f:
                                  f.write(b'#!/bin/sh\n')
                                  escaped_exec = shellquote(_bytes2sys(real_exec))
                                  f.write(b'%s "$@"\n' % _sys2bytes(escaped_exec))
                          else:
                              os.symlink(real_exec, target_exec)
                          self._createdfiles.append(target_exec)
                  def _installhg(self):
                      """Install hg into the test environment.
                      This will also configure hg with the appropriate testing settings.
                      """
                      vlog("# Performing temporary installation of HG")
                      installerrs = os.path.join(self._hgtmp, b"install.err")
                      compiler = ''
                      if self.options.compiler:
                          compiler = '--compiler ' + self.options.compiler
                      setup_opts = b""
                      if self.options.pure:
                          setup_opts = b"--pure"
                      elif self.options.rust:
                          setup_opts = b"--rust"
                      elif self.options.no_rust:
                          setup_opts = b"--no-rust"
                      # Run installer in hg root
                      compiler = _sys2bytes(compiler)
                      script = _sys2bytes(os.path.realpath(sys.argv[0]))
                      exe = _sys2bytes(sysexecutable)
                      hgroot = os.path.dirname(os.path.dirname(script))
                      self._hgroot = hgroot
                      os.chdir(hgroot)
                      nohome = b'--home=""'
                      if WINDOWS:
                          # The --home="" trick works only on OS where os.sep == '/'
                          # because of a distutils convert_path() fast-path. Avoid it at
                          # least on Windows for now, deal with .pydistutils.cfg bugs
                          # when they happen.
                          nohome = b''
                      cmd = (
                          b'"%(exe)s" setup.py %(setup_opts)s clean --all'
                          b' build %(compiler)s --build-base="%(base)s"'
                          b' install --force --prefix="%(prefix)s"'
                          b' --install-lib="%(libdir)s"'
                          b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1'
                          % {
                              b'exe': exe,
                              b'setup_opts': setup_opts,
                              b'compiler': compiler,
                              b'base': os.path.join(self._hgtmp, b"build"),
                              b'prefix': self._installdir,
                              b'libdir': self._pythondir,
                              b'bindir': self._bindir,
                              b'nohome': nohome,
                              b'logfile': installerrs,
                          }
                      )
                      # setuptools requires install directories to exist.
                      def makedirs(p):
                          try:
                              os.makedirs(p)
                          except FileExistsError:
                              pass
                      makedirs(self._pythondir)
                      makedirs(self._bindir)
                      vlog("# Running", cmd.decode("utf-8"))
-                     if subprocess.call(_bytes2sys(cmd), shell=True) == 0:
+                     if subprocess.call(_bytes2sys(cmd), shell=True, env=original_env) == 0:
                          if not self.options.verbose:
                              try:
                                  os.remove(installerrs)
                              except FileNotFoundError:
                                  pass
                      else:
                          with open(installerrs, 'rb') as f:
                              for line in f:
                                  sys.stdout.buffer.write(line)
                          sys.exit(1)
                      os.chdir(self._testdir)
                      hgbat = os.path.join(self._bindir, b'hg.bat')
                      if os.path.isfile(hgbat):
                          # hg.bat expects to be put in bin/scripts while run-tests.py
                          # installation layout put it in bin/ directly. Fix it
                          with open(hgbat, 'rb') as f:
                              data = f.read()
                          if br'"%~dp0..\python" "%~dp0hg" %*' in data:
                              data = data.replace(
                                  br'"%~dp0..\python" "%~dp0hg" %*',
                                  b'"%~dp0python" "%~dp0hg" %*',
                              )
                              with open(hgbat, 'wb') as f:
                                  f.write(data)
                          else:
                              print('WARNING: cannot fix hg.bat reference to python.exe')
                      if self.options.anycoverage:
                          custom = os.path.join(
                              osenvironb[b'RUNTESTDIR'], b'sitecustomize.py'
                          )
                          target = os.path.join(self._pythondir, b'sitecustomize.py')
                          vlog('# Installing coverage trigger to %s' % target)
                          shutil.copyfile(custom, target)
                          rc = os.path.join(self._testdir, b'.coveragerc')
                          vlog('# Installing coverage rc to %s' % rc)
                          osenvironb[b'COVERAGE_PROCESS_START'] = rc
                          covdir = os.path.join(self._installdir, b'..', b'coverage')
                          try:
                              os.mkdir(covdir)
                          except FileExistsError:
                              pass
                          osenvironb[b'COVERAGE_DIR'] = covdir
                  def _checkhglib(self, verb):
                      """Ensure that the 'mercurial' package imported by python is
                      the one we expect it to be.  If not, print a warning to stderr."""
                      if self._pythondir_inferred:
                          # The pythondir has been inferred from --with-hg flag.
                          # We cannot expect anything sensible here.
                          return
                      expecthg = os.path.join(self._pythondir, b'mercurial')
                      actualhg = self._gethgpath()
                      if os.path.abspath(actualhg) != os.path.abspath(expecthg):
                          sys.stderr.write(
                              'warning: %s with unexpected mercurial lib: %s\n'
                              '         (expected %s)\n' % (verb, actualhg, expecthg)
                          )
                  def _gethgpath(self):
                      """Return the path to the mercurial package that is actually found by
                      the current Python interpreter."""
                      if self._hgpath is not None:
                          return self._hgpath
                      cmd = b'"%s" -c "import mercurial; print (mercurial.__path__[0])"'
                      cmd = _bytes2sys(cmd % PYTHON)
                      p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
                      out, err = p.communicate()
                      self._hgpath = out.strip()
                      return self._hgpath
                  def _installchg(self):
                      """Install chg into the test environment"""
                      vlog('# Performing temporary installation of CHG')
                      assert os.path.dirname(self._bindir) == self._installdir
                      assert self._hgroot, 'must be called after _installhg()'
                      cmd = b'"%(make)s" clean install PREFIX="%(prefix)s"' % {
                          b'make': b'make',  # TODO: switch by option or environment?
                          b'prefix': self._installdir,
                      }
                      cwd = os.path.join(self._hgroot, b'contrib', b'chg')
                      vlog("# Running", cmd)
                      proc = subprocess.Popen(
                          cmd,
                          shell=True,
                          cwd=cwd,
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.STDOUT,
                      )
                      out, _err = proc.communicate()
                      if proc.returncode != 0:
                          sys.stdout.buffer.write(out)
                          sys.exit(1)
                  def _installrhg(self):
                      """Install rhg into the test environment"""
                      vlog('# Performing temporary installation of rhg')
                      assert os.path.dirname(self._bindir) == self._installdir
                      assert self._hgroot, 'must be called after _installhg()'
                      cmd = b'"%(make)s" install-rhg PREFIX="%(prefix)s"' % {
                          b'make': b'make',  # TODO: switch by option or environment?
                          b'prefix': self._installdir,
                      }
                      cwd = self._hgroot
                      vlog("# Running", cmd)
                      proc = subprocess.Popen(
                          cmd,
                          shell=True,
                          cwd=cwd,
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.STDOUT,
                      )
                      out, _err = proc.communicate()
                      if proc.returncode != 0:
                          sys.stdout.buffer.write(out)
                          sys.exit(1)
                  def _build_pyoxidized(self):
                      """build a pyoxidized version of mercurial into the test environment
                      Ideally this function would be `install_pyoxidier` and would both build
                      and install pyoxidier. However we are starting small to get pyoxidizer
                      build binary to testing quickly.
                      """
                      vlog('# build a pyoxidized version of Mercurial')
                      assert os.path.dirname(self._bindir) == self._installdir
                      assert self._hgroot, 'must be called after _installhg()'
                      target = b''
                      if WINDOWS:
                          target = b'windows'
                      elif MACOS:
                          target = b'macos'
                      cmd = b'"%(make)s" pyoxidizer-%(platform)s-tests' % {
                          b'make': b'make',
                          b'platform': target,
                      }
                      cwd = self._hgroot
                      vlog("# Running", cmd)
                      proc = subprocess.Popen(
                          _bytes2sys(cmd),
                          shell=True,
                          cwd=_bytes2sys(cwd),
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.STDOUT,
                      )
                      out, _err = proc.communicate()
                      if proc.returncode != 0:
                          sys.stdout.buffer.write(out)
                          sys.exit(1)
                      cmd = _bytes2sys(b"%s debuginstall -Tjson" % self._hgcommand)
                      p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
                      out, err = p.communicate()
                      props = json.loads(out)[0]
                      # Affects hghave.py
                      osenvironb.pop(b'PYOXIDIZED_IN_MEMORY_RSRC', None)
                      osenvironb.pop(b'PYOXIDIZED_FILESYSTEM_RSRC', None)
                      if props["hgmodules"] == props["pythonexe"]:
                          osenvironb[b'PYOXIDIZED_IN_MEMORY_RSRC'] = b'1'
                      else:
                          osenvironb[b'PYOXIDIZED_FILESYSTEM_RSRC'] = b'1'
                  def _outputcoverage(self):
                      """Produce code coverage output."""
                      import coverage
                      coverage = coverage.coverage
                      vlog('# Producing coverage report')
                      # chdir is the easiest way to get short, relative paths in the
                      # output.
                      os.chdir(self._hgroot)
                      covdir = os.path.join(_bytes2sys(self._installdir), '..', 'coverage')
                      cov = coverage(data_file=os.path.join(covdir, 'cov'))
                      # Map install directory paths back to source directory.
                      cov.config.paths['srcdir'] = ['.', _bytes2sys(self._pythondir)]
                      cov.combine()
                      omit = [
                          _bytes2sys(os.path.join(x, b'*'))
                          for x in [self._bindir, self._testdir]
                      ]
                      cov.report(ignore_errors=True, omit=omit)
                      if self.options.htmlcov:
                          htmldir = os.path.join(_bytes2sys(self._outputdir), 'htmlcov')
                          cov.html_report(directory=htmldir, omit=omit)
                      if self.options.annotate:
                          adir = os.path.join(_bytes2sys(self._outputdir), 'annotated')
                          if not os.path.isdir(adir):
                              os.mkdir(adir)
                          cov.annotate(directory=adir, omit=omit)
                  def _findprogram(self, program):
                      """Search PATH for a executable program"""
                      dpb = _sys2bytes(os.defpath)
                      sepb = _sys2bytes(os.pathsep)
                      for p in osenvironb.get(b'PATH', dpb).split(sepb):
                          name = os.path.join(p, program)
                          if WINDOWS or os.access(name, os.X_OK):
                              return _bytes2sys(name)
                      return None
                  def _checktools(self):
                      """Ensure tools required to run tests are present."""
                      for p in self.REQUIREDTOOLS:
                          if WINDOWS and not p.endswith(b'.exe'):
                              p += b'.exe'
                          found = self._findprogram(p)
                          p = p.decode("utf-8")
                          if found:
                              vlog("# Found prerequisite", p, "at", found)
                          else:
                              print("WARNING: Did not find prerequisite tool: %s " % p)
              def aggregateexceptions(path):
                  exceptioncounts = collections.Counter()
                  testsbyfailure = collections.defaultdict(set)
                  failuresbytest = collections.defaultdict(set)
                  for f in os.listdir(path):
                      with open(os.path.join(path, f), 'rb') as fh:
                          data = fh.read().split(b'\0')
                          if len(data) != 5:
                              continue
                          exc, mainframe, hgframe, hgline, testname = data
                          exc = exc.decode('utf-8')
                          mainframe = mainframe.decode('utf-8')
                          hgframe = hgframe.decode('utf-8')
                          hgline = hgline.decode('utf-8')
                          testname = testname.decode('utf-8')
                          key = (hgframe, hgline, exc)
                          exceptioncounts[key] += 1
                          testsbyfailure[key].add(testname)
                          failuresbytest[testname].add(key)
                  # Find test having fewest failures for each failure.
                  leastfailing = {}
                  for key, tests in testsbyfailure.items():
                      fewesttest = None
                      fewestcount = 99999999
                      for test in sorted(tests):
                          if len(failuresbytest[test]) < fewestcount:
                              fewesttest = test
                              fewestcount = len(failuresbytest[test])
                      leastfailing[key] = (fewestcount, fewesttest)
                  # Create a combined counter so we can sort by total occurrences and
                  # impacted tests.
                  combined = {}
                  for key in exceptioncounts:
                      combined[key] = (
                          exceptioncounts[key],
                          len(testsbyfailure[key]),
                          leastfailing[key][0],
                          leastfailing[key][1],
                      )
                  return {
                      'exceptioncounts': exceptioncounts,
                      'total': sum(exceptioncounts.values()),
                      'combined': combined,
                      'leastfailing': leastfailing,
                      'byfailure': testsbyfailure,
                      'bytest': failuresbytest,
                  }
              if __name__ == '__main__':
                  if WINDOWS and not os.getenv('MSYSTEM'):
                      print('cannot run test on Windows without MSYSTEM', file=sys.stderr)
                      print(
                          '(if you need to do so contact the mercurial devs: '
                          'mercurial@mercurial-scm.org)',
                          file=sys.stderr,
                      )
                      sys.exit(255)
                  runner = TestRunner()
                  try:
                      import msvcrt
                      msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
                      msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
                      msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
                  except ImportError:
                      pass
                  sys.exit(runner.run(sys.argv[1:]))

General Comments 0

Write
Preview

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

No TODOs yet

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

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