upstream/mercurial-mirror Commit - r50139:cd51d495

branching: merge stable into default

Raphaël Gomès -

r50139:cd51d495 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=

.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

hgext/narrow/narrowwirepeer.py

0 +6 0

              # narrowwirepeer.py - passes narrow spec with unbundle command
              #
              # Copyright 2017 Google, Inc.
              #
              # This software may be used and distributed according to the terms of the
              # GNU General Public License version 2 or any later version.
              from mercurial import (
                  bundle2,
                  error,
+                 exchange,
                  extensions,
                  hg,
                  narrowspec,
                  wireprototypes,
                  wireprotov1peer,
                  wireprotov1server,
              )
              from . import narrowbundle2
              def uisetup():
                  wireprotov1peer.wirepeer.narrow_widen = peernarrowwiden
              def reposetup(repo):
                  def wirereposetup(ui, peer):
                      def wrapped(orig, cmd, *args, **kwargs):
                          if cmd == b'unbundle':
                              # TODO: don't blindly add include/exclude wireproto
                              # arguments to unbundle.
                              include, exclude = repo.narrowpats
                              kwargs["includepats"] = b','.join(include)
                              kwargs["excludepats"] = b','.join(exclude)
                          return orig(cmd, *args, **kwargs)
                      extensions.wrapfunction(peer, b'_calltwowaystream', wrapped)
                  hg.wirepeersetupfuncs.append(wirereposetup)
              @wireprotov1server.wireprotocommand(
                  b'narrow_widen',
                  b'oldincludes oldexcludes'
                  b' newincludes newexcludes'
                  b' commonheads cgversion'
                  b' known ellipses',
                  permission=b'pull',
              )
              def narrow_widen(
                  repo,
                  proto,
                  oldincludes,
                  oldexcludes,
                  newincludes,
                  newexcludes,
                  commonheads,
                  cgversion,
                  known,
                  ellipses,
              ):
                  """wireprotocol command to send data when a narrow clone is widen. We will
                  be sending a changegroup here.
                  The current set of arguments which are required:
                  oldincludes: the old includes of the narrow copy
                  oldexcludes: the old excludes of the narrow copy
                  newincludes: the new includes of the narrow copy
                  newexcludes: the new excludes of the narrow copy
                  commonheads: list of heads which are common between the server and client
                  cgversion(maybe): the changegroup version to produce
                  known: list of nodes which are known on the client (used in ellipses cases)
                  ellipses: whether to send ellipses data or not
                  """
                  preferuncompressed = False
                  try:
                      def splitpaths(data):
                          # work around ''.split(',') => ['']
                          return data.split(b',') if data else []
                      oldincludes = splitpaths(oldincludes)
                      newincludes = splitpaths(newincludes)
                      oldexcludes = splitpaths(oldexcludes)
                      newexcludes = splitpaths(newexcludes)
+                     # enforce narrow acl if set
+                     if repo.ui.has_section(exchange._NARROWACL_SECTION):
+                         exchange.applynarrowacl(repo, {'includepats': newincludes})
                      # validate the patterns
                      narrowspec.validatepatterns(set(oldincludes))
                      narrowspec.validatepatterns(set(newincludes))
                      narrowspec.validatepatterns(set(oldexcludes))
                      narrowspec.validatepatterns(set(newexcludes))
                      common = wireprototypes.decodelist(commonheads)
                      known = wireprototypes.decodelist(known)
                      if ellipses == b'0':
                          ellipses = False
                      else:
                          ellipses = bool(ellipses)
                      cgversion = cgversion
                      bundler = bundle2.bundle20(repo.ui)
                      newmatch = narrowspec.match(
                          repo.root, include=newincludes, exclude=newexcludes
                      )
                      oldmatch = narrowspec.match(
                          repo.root, include=oldincludes, exclude=oldexcludes
                      )
                      if not ellipses:
                          bundle2.widen_bundle(
                              bundler,
                              repo,
                              oldmatch,
                              newmatch,
                              common,
                              known,
                              cgversion,
                              ellipses,
                          )
                      else:
                          narrowbundle2.generate_ellipses_bundle2_for_widening(
                              bundler,
                              repo,
                              oldmatch,
                              newmatch,
                              cgversion,
                              common,
                              known,
                          )
                  except error.Abort as exc:
                      bundler = bundle2.bundle20(repo.ui)
                      manargs = [(b'message', exc.message)]
                      advargs = []
                      if exc.hint is not None:
                          advargs.append((b'hint', exc.hint))
                      bundler.addpart(bundle2.bundlepart(b'error:abort', manargs, advargs))
                      preferuncompressed = True
                  chunks = bundler.getchunks()
                  return wireprototypes.streamres(
                      gen=chunks, prefer_uncompressed=preferuncompressed
                  )
              def peernarrowwiden(remote, **kwargs):
                  for ch in ('commonheads', 'known'):
                      kwargs[ch] = wireprototypes.encodelist(kwargs[ch])
                  for ch in ('oldincludes', 'newincludes', 'oldexcludes', 'newexcludes'):
                      kwargs[ch] = b','.join(kwargs[ch])
                  kwargs['ellipses'] = b'%i' % bool(kwargs['ellipses'])
                  f = remote._callcompressable(b'narrow_widen', **kwargs)
                  return bundle2.getunbundler(remote.ui, f)

mercurial/chgserver.py

0 +1 -1

              # chgserver.py - command server extension for cHg
              #
              # Copyright 2011 Yuya Nishihara <yuya@tcha.org>
              #
              # This software may be used and distributed according to the terms of the
              # GNU General Public License version 2 or any later version.
              """command server extension for cHg
              'S' channel (read/write)
                  propagate ui.system() request to client
              'attachio' command
                  attach client's stdio passed by sendmsg()
              'chdir' command
                  change current directory
              'setenv' command
                  replace os.environ completely
              'setumask' command (DEPRECATED)
              'setumask2' command
                  set umask
              'validate' command
                  reload the config and check if the server is up to date
              Config
              ------
              ::
                [chgserver]
                # how long (in seconds) should an idle chg server exit
                idletimeout = 3600
                # whether to skip config or env change checks
                skiphash = False
              """
              import inspect
              import os
              import re
              import socket
              import stat
              import struct
              import time
              from .i18n import _
              from .pycompat import (
                  getattr,
                  setattr,
              )
              from .node import hex
              from . import (
                  commandserver,
                  encoding,
                  error,
                  extensions,
                  pycompat,
                  util,
              )
              from .utils import (
                  hashutil,
                  procutil,
                  stringutil,
              )
              def _hashlist(items):
                  """return sha1 hexdigest for a list"""
                  return hex(hashutil.sha1(stringutil.pprint(items)).digest())
              # sensitive config sections affecting confighash
              _configsections = [
                  b'alias',  # affects global state commands.table
                  b'diff-tools',  # affects whether gui or not in extdiff's uisetup
                  b'eol',  # uses setconfig('eol', ...)
                  b'extdiff',  # uisetup will register new commands
                  b'extensions',
                  b'fastannotate',  # affects annotate command and adds fastannonate cmd
                  b'merge-tools',  # affects whether gui or not in extdiff's uisetup
                  b'schemes',  # extsetup will update global hg.schemes
              ]
              _configsectionitems = [
                  (b'commands', b'show.aliasprefix'),  # show.py reads it in extsetup
              ]
              # sensitive environment variables affecting confighash
              _envre = re.compile(
                  br'''\A(?:
                                  CHGHG
                                  |HG(?:DEMANDIMPORT|EMITWARNINGS|MODULEPOLICY|PROF|RCPATH)?
                                  |HG(?:ENCODING|PLAIN).*
                                  |LANG(?:UAGE)?
                                  |LC_.*
                                  |LD_.*
                                  |PATH
                                  |PYTHON.*
                                  |TERM(?:INFO)?
                                  |TZ
                                  )\Z''',
                  re.X,
              )
              def _confighash(ui):
                  """return a quick hash for detecting config/env changes
                  confighash is the hash of sensitive config items and environment variables.
                  for chgserver, it is designed that once confighash changes, the server is
                  not qualified to serve its client and should redirect the client to a new
                  server. different from mtimehash, confighash change will not mark the
                  server outdated and exit since the user can have different configs at the
                  same time.
                  """
                  sectionitems = []
                  for section in _configsections:
                      sectionitems.append(ui.configitems(section))
                  for section, item in _configsectionitems:
                      sectionitems.append(ui.config(section, item))
                  sectionhash = _hashlist(sectionitems)
                  # If $CHGHG is set, the change to $HG should not trigger a new chg server
                  if b'CHGHG' in encoding.environ:
                      ignored = {b'HG'}
                  else:
                      ignored = set()
                  envitems = [
                      (k, v)
                      for k, v in encoding.environ.items()
                      if _envre.match(k) and k not in ignored
                  ]
                  envhash = _hashlist(sorted(envitems))
                  return sectionhash[:6] + envhash[:6]
              def _getmtimepaths(ui):
                  """get a list of paths that should be checked to detect change
                  The list will include:
                  - extensions (will not cover all files for complex extensions)
                  - mercurial/__version__.py
                  - python binary
                  """
                  modules = [m for n, m in extensions.extensions(ui)]
                  try:
                      from . import __version__
                      modules.append(__version__)
                  except ImportError:
                      pass
                  files = []
                  if pycompat.sysexecutable:
                      files.append(pycompat.sysexecutable)
                  for m in modules:
                      try:
                          files.append(pycompat.fsencode(inspect.getabsfile(m)))
                      except TypeError:
                          pass
                  return sorted(set(files))
              def _mtimehash(paths):
                  """return a quick hash for detecting file changes
                  mtimehash calls stat on given paths and calculate a hash based on size and
                  mtime of each file. mtimehash does not read file content because reading is
                  expensive. therefore it's not 100% reliable for detecting content changes.
                  it's possible to return different hashes for same file contents.
                  it's also possible to return a same hash for different file contents for
                  some carefully crafted situation.
                  for chgserver, it is designed that once mtimehash changes, the server is
                  considered outdated immediately and should no longer provide service.
                  mtimehash is not included in confighash because we only know the paths of
                  extensions after importing them (there is imp.find_module but that faces
                  race conditions). We need to calculate confighash without importing.
                  """
                  def trystat(path):
                      try:
                          st = os.stat(path)
                          return (st[stat.ST_MTIME], st.st_size)
                      except OSError:
                          # could be ENOENT, EPERM etc. not fatal in any case
                          pass
                  return _hashlist(pycompat.maplist(trystat, paths))[:12]
              class hashstate:
                  """a structure storing confighash, mtimehash, paths used for mtimehash"""
                  def __init__(self, confighash, mtimehash, mtimepaths):
                      self.confighash = confighash
                      self.mtimehash = mtimehash
                      self.mtimepaths = mtimepaths
                  @staticmethod
                  def fromui(ui, mtimepaths=None):
                      if mtimepaths is None:
                          mtimepaths = _getmtimepaths(ui)
                      confighash = _confighash(ui)
                      mtimehash = _mtimehash(mtimepaths)
                      ui.log(
                          b'cmdserver',
                          b'confighash = %s mtimehash = %s\n',
                          confighash,
                          mtimehash,
                      )
                      return hashstate(confighash, mtimehash, mtimepaths)
              def _newchgui(srcui, csystem, attachio):
                  class chgui(srcui.__class__):
                      def __init__(self, src=None):
                          super(chgui, self).__init__(src)
                          if src:
                              self._csystem = getattr(src, '_csystem', csystem)
                          else:
                              self._csystem = csystem
                      def _runsystem(self, cmd, environ, cwd, out):
                          # fallback to the original system method if
                          #  a. the output stream is not stdout (e.g. stderr, cStringIO),
                          #  b. or stdout is redirected by protectfinout(),
                          # because the chg client is not aware of these situations and
                          # will behave differently (i.e. write to stdout).
                          if (
                              out is not self.fout
                              or not util.safehasattr(self.fout, b'fileno')
                              or self.fout.fileno() != procutil.stdout.fileno()
                              or self._finoutredirected
                          ):
                              return procutil.system(cmd, environ=environ, cwd=cwd, out=out)
                          self.flush()
                          return self._csystem(cmd, procutil.shellenviron(environ), cwd)
                      def _runpager(self, cmd, env=None):
                          self._csystem(
                              cmd,
                              procutil.shellenviron(env),
                              type=b'pager',
                              cmdtable={b'attachio': attachio},
                          )
                          return True
                  return chgui(srcui)
              def _loadnewui(srcui, args, cdebug):
                  from . import dispatch  # avoid cycle
                  newui = srcui.__class__.load()
                  for a in [b'fin', b'fout', b'ferr', b'environ']:
                      setattr(newui, a, getattr(srcui, a))
                  if util.safehasattr(srcui, b'_csystem'):
                      newui._csystem = srcui._csystem
                  # command line args
                  options = dispatch._earlyparseopts(newui, args)
                  dispatch._parseconfig(newui, options[b'config'])
                  # stolen from tortoisehg.util.copydynamicconfig()
                  for section, name, value in srcui.walkconfig():
                      source = srcui.configsource(section, name)
                      if b':' in source or source == b'--config' or source.startswith(b'$'):
                          # path:line or command line, or environ
                          continue
                      newui.setconfig(section, name, value, source)
                  # load wd and repo config, copied from dispatch.py
                  cwd = options[b'cwd']
                  cwd = cwd and os.path.realpath(cwd) or None
                  rpath = options[b'repository']
                  path, newlui = dispatch._getlocal(newui, rpath, wd=cwd)
                  extensions.populateui(newui)
                  commandserver.setuplogging(newui, fp=cdebug)
                  if newui is not newlui:
                      extensions.populateui(newlui)
                      commandserver.setuplogging(newlui, fp=cdebug)
                  return (newui, newlui)
              class channeledsystem:
                  """Propagate ui.system() request in the following format:
                  payload length (unsigned int),
                  type, '\0',
                  cmd, '\0',
                  cwd, '\0',
                  envkey, '=', val, '\0',
                  ...
                  envkey, '=', val
                  if type == 'system', waits for:
                  exitcode length (unsigned int),
                  exitcode (int)
                  if type == 'pager', repetitively waits for a command name ending with '\n'
                  and executes it defined by cmdtable, or exits the loop if the command name
                  is empty.
                  """
                  def __init__(self, in_, out, channel):
                      self.in_ = in_
                      self.out = out
                      self.channel = channel
                  def __call__(self, cmd, environ, cwd=None, type=b'system', cmdtable=None):
                      args = [type, cmd, util.abspath(cwd or b'.')]
                      args.extend(b'%s=%s' % (k, v) for k, v in environ.items())
                      data = b'\0'.join(args)
                      self.out.write(struct.pack(b'>cI', self.channel, len(data)))
                      self.out.write(data)
                      self.out.flush()
                      if type == b'system':
                          length = self.in_.read(4)
                          (length,) = struct.unpack(b'>I', length)
                          if length != 4:
                              raise error.Abort(_(b'invalid response'))
                          (rc,) = struct.unpack(b'>i', self.in_.read(4))
                          return rc
                      elif type == b'pager':
                          while True:
                              cmd = self.in_.readline()[:-1]
                              if not cmd:
                                  break
                              if cmdtable and cmd in cmdtable:
                                  cmdtable[cmd]()
                              else:
                                  raise error.Abort(_(b'unexpected command: %s') % cmd)
                      else:
                          raise error.ProgrammingError(b'invalid S channel type: %s' % type)
              _iochannels = [
                  # server.ch, ui.fp, mode
                  (b'cin', b'fin', 'rb'),
                  (b'cout', b'fout', 'wb'),
                  (b'cerr', b'ferr', 'wb'),
              ]
              class chgcmdserver(commandserver.server):
                  def __init__(
                      self, ui, repo, fin, fout, sock, prereposetups, hashstate, baseaddress
                  ):
                      super(chgcmdserver, self).__init__(
                          _newchgui(ui, channeledsystem(fin, fout, b'S'), self.attachio),
                          repo,
                          fin,
                          fout,
                          prereposetups,
                      )
                      self.clientsock = sock
                      self._ioattached = False
                      self._oldios = []  # original (self.ch, ui.fp, fd) before "attachio"
                      self.hashstate = hashstate
                      self.baseaddress = baseaddress
                      if hashstate is not None:
                          self.capabilities = self.capabilities.copy()
                          self.capabilities[b'validate'] = chgcmdserver.validate
                  def cleanup(self):
                      super(chgcmdserver, self).cleanup()
                      # dispatch._runcatch() does not flush outputs if exception is not
                      # handled by dispatch._dispatch()
                      self.ui.flush()
                      self._restoreio()
                      self._ioattached = False
                  def attachio(self):
                      """Attach to client's stdio passed via unix domain socket; all
                      channels except cresult will no longer be used
                      """
                      # tell client to sendmsg() with 1-byte payload, which makes it
                      # distinctive from "attachio\n" command consumed by client.read()
                      self.clientsock.sendall(struct.pack(b'>cI', b'I', 1))
                      clientfds = util.recvfds(self.clientsock.fileno())
                      self.ui.log(b'chgserver', b'received fds: %r\n', clientfds)
                      ui = self.ui
                      ui.flush()
                      self._saveio()
                      for fd, (cn, fn, mode) in zip(clientfds, _iochannels):
                          assert fd > 0
                          fp = getattr(ui, fn)
                          os.dup2(fd, fp.fileno())
                          os.close(fd)
                          if self._ioattached:
                              continue
                          # reset buffering mode when client is first attached. as we want
                          # to see output immediately on pager, the mode stays unchanged
                          # when client re-attached. ferr is unchanged because it should
                          # be unbuffered no matter if it is a tty or not.
                          if fn == b'ferr':
                              newfp = fp
                          else:
                              # On Python 3, the standard library doesn't offer line-buffered
                              # binary streams, so wrap/unwrap it.
                              if fp.isatty():
                                  newfp = procutil.make_line_buffered(fp)
                              else:
                                  newfp = procutil.unwrap_line_buffered(fp)
                          if newfp is not fp:
                              setattr(ui, fn, newfp)
                          setattr(self, cn, newfp)
                      self._ioattached = True
                      self.cresult.write(struct.pack(b'>i', len(clientfds)))
                  def _saveio(self):
                      if self._oldios:
                          return
                      ui = self.ui
                      for cn, fn, _mode in _iochannels:
                          ch = getattr(self, cn)
                          fp = getattr(ui, fn)
                          fd = os.dup(fp.fileno())
                          self._oldios.append((ch, fp, fd))
                  def _restoreio(self):
                      if not self._oldios:
                          return
                      nullfd = os.open(os.devnull, os.O_WRONLY)
                      ui = self.ui
                      for (ch, fp, fd), (cn, fn, mode) in zip(self._oldios, _iochannels):
                          try:
                              if 'w' in mode:
                                  # Discard buffered data which couldn't be flushed because
                                  # of EPIPE. The data should belong to the current session
                                  # and should never persist.
                                  os.dup2(nullfd, fp.fileno())
                                  fp.flush()
                              os.dup2(fd, fp.fileno())
+                             os.close(fd)
                          except OSError as err:
                              # According to issue6330, running chg on heavy loaded systems
                              # can lead to EBUSY. [man dup2] indicates that, on Linux,
                              # EBUSY comes from a race condition between open() and dup2().
                              # However it's not clear why open() race occurred for
                              # newfd=stdin/out/err.
                              self.ui.log(
                                  b'chgserver',
                                  b'got %s while duplicating %s\n',
                                  stringutil.forcebytestr(err),
                                  fn,
                              )
-                         os.close(fd)
                          setattr(self, cn, ch)
                          setattr(ui, fn, fp)
                      os.close(nullfd)
                      del self._oldios[:]
                  def validate(self):
                      """Reload the config and check if the server is up to date
                      Read a list of '\0' separated arguments.
                      Write a non-empty list of '\0' separated instruction strings or '\0'
                      if the list is empty.
                      An instruction string could be either:
                          - "unlink $path", the client should unlink the path to stop the
                            outdated server.
                          - "redirect $path", the client should attempt to connect to $path
                            first. If it does not work, start a new server. It implies
                            "reconnect".
                          - "exit $n", the client should exit directly with code n.
                            This may happen if we cannot parse the config.
                          - "reconnect", the client should close the connection and
                            reconnect.
                      If neither "reconnect" nor "redirect" is included in the instruction
                      list, the client can continue with this server after completing all
                      the instructions.
                      """
                      args = self._readlist()
                      errorraised = False
                      detailed_exit_code = 255
                      try:
                          self.ui, lui = _loadnewui(self.ui, args, self.cdebug)
                      except error.RepoError as inst:
                          # RepoError can be raised while trying to read shared source
                          # configuration
                          self.ui.error(_(b"abort: %s\n") % stringutil.forcebytestr(inst))
                          if inst.hint:
                              self.ui.error(_(b"(%s)\n") % inst.hint)
                          errorraised = True
                      except error.Error as inst:
                          if inst.detailed_exit_code is not None:
                              detailed_exit_code = inst.detailed_exit_code
                          self.ui.error(inst.format())
                          errorraised = True
                      if errorraised:
                          self.ui.flush()
                          exit_code = 255
                          if self.ui.configbool(b'ui', b'detailed-exit-code'):
                              exit_code = detailed_exit_code
                          self.cresult.write(b'exit %d' % exit_code)
                          return
                      newhash = hashstate.fromui(lui, self.hashstate.mtimepaths)
                      insts = []
                      if newhash.mtimehash != self.hashstate.mtimehash:
                          addr = _hashaddress(self.baseaddress, self.hashstate.confighash)
                          insts.append(b'unlink %s' % addr)
                          # mtimehash is empty if one or more extensions fail to load.
                          # to be compatible with hg, still serve the client this time.
                          if self.hashstate.mtimehash:
                              insts.append(b'reconnect')
                      if newhash.confighash != self.hashstate.confighash:
                          addr = _hashaddress(self.baseaddress, newhash.confighash)
                          insts.append(b'redirect %s' % addr)
                      self.ui.log(b'chgserver', b'validate: %s\n', stringutil.pprint(insts))
                      self.cresult.write(b'\0'.join(insts) or b'\0')
                  def chdir(self):
                      """Change current directory
                      Note that the behavior of --cwd option is bit different from this.
                      It does not affect --config parameter.
                      """
                      path = self._readstr()
                      if not path:
                          return
                      self.ui.log(b'chgserver', b"chdir to '%s'\n", path)
                      os.chdir(path)
                  def setumask(self):
                      """Change umask (DEPRECATED)"""
                      # BUG: this does not follow the message frame structure, but kept for
                      # backward compatibility with old chg clients for some time
                      self._setumask(self._read(4))
                  def setumask2(self):
                      """Change umask"""
                      data = self._readstr()
                      if len(data) != 4:
                          raise ValueError(b'invalid mask length in setumask2 request')
                      self._setumask(data)
                  def _setumask(self, data):
                      mask = struct.unpack(b'>I', data)[0]
                      self.ui.log(b'chgserver', b'setumask %r\n', mask)
                      util.setumask(mask)
                  def runcommand(self):
                      # pager may be attached within the runcommand session, which should
                      # be detached at the end of the session. otherwise the pager wouldn't
                      # receive EOF.
                      globaloldios = self._oldios
                      self._oldios = []
                      try:
                          return super(chgcmdserver, self).runcommand()
                      finally:
                          self._restoreio()
                          self._oldios = globaloldios
                  def setenv(self):
                      """Clear and update os.environ
                      Note that not all variables can make an effect on the running process.
                      """
                      l = self._readlist()
                      try:
                          newenv = dict(s.split(b'=', 1) for s in l)
                      except ValueError:
                          raise ValueError(b'unexpected value in setenv request')
                      self.ui.log(b'chgserver', b'setenv: %r\n', sorted(newenv.keys()))
                      encoding.environ.clear()
                      encoding.environ.update(newenv)
                  capabilities = commandserver.server.capabilities.copy()
                  capabilities.update(
                      {
                          b'attachio': attachio,
                          b'chdir': chdir,
                          b'runcommand': runcommand,
                          b'setenv': setenv,
                          b'setumask': setumask,
                          b'setumask2': setumask2,
                      }
                  )
                  if util.safehasattr(procutil, b'setprocname'):
                      def setprocname(self):
                          """Change process title"""
                          name = self._readstr()
                          self.ui.log(b'chgserver', b'setprocname: %r\n', name)
                          procutil.setprocname(name)
                      capabilities[b'setprocname'] = setprocname
              def _tempaddress(address):
                  return b'%s.%d.tmp' % (address, os.getpid())
              def _hashaddress(address, hashstr):
                  # if the basename of address contains '.', use only the left part. this
                  # makes it possible for the client to pass 'server.tmp$PID' and follow by
                  # an atomic rename to avoid locking when spawning new servers.
                  dirname, basename = os.path.split(address)
                  basename = basename.split(b'.', 1)[0]
                  return b'%s-%s' % (os.path.join(dirname, basename), hashstr)
              class chgunixservicehandler:
                  """Set of operations for chg services"""
                  pollinterval = 1  # [sec]
                  def __init__(self, ui):
                      self.ui = ui
                      # TODO: use PEP 526 syntax (`_hashstate: hashstate` at the class level)
                      #  when 3.5 support is dropped.
                      self._hashstate = None  # type: hashstate
                      self._baseaddress = None  # type: bytes
                      self._realaddress = None  # type: bytes
                      self._idletimeout = ui.configint(b'chgserver', b'idletimeout')
                      self._lastactive = time.time()
                  def bindsocket(self, sock, address):
                      self._inithashstate(address)
                      self._checkextensions()
                      self._bind(sock)
                      self._createsymlink()
                      # no "listening at" message should be printed to simulate hg behavior
                  def _inithashstate(self, address):
                      self._baseaddress = address
                      if self.ui.configbool(b'chgserver', b'skiphash'):
                          self._hashstate = None
                          self._realaddress = address
                          return
                      self._hashstate = hashstate.fromui(self.ui)
                      self._realaddress = _hashaddress(address, self._hashstate.confighash)
                  def _checkextensions(self):
                      if not self._hashstate:
                          return
                      if extensions.notloaded():
                          # one or more extensions failed to load. mtimehash becomes
                          # meaningless because we do not know the paths of those extensions.
                          # set mtimehash to an illegal hash value to invalidate the server.
                          self._hashstate.mtimehash = b''
                  def _bind(self, sock):
                      # use a unique temp address so we can stat the file and do ownership
                      # check later
                      tempaddress = _tempaddress(self._realaddress)
                      util.bindunixsocket(sock, tempaddress)
                      self._socketstat = os.stat(tempaddress)
                      sock.listen(socket.SOMAXCONN)
                      # rename will replace the old socket file if exists atomically. the
                      # old server will detect ownership change and exit.
                      util.rename(tempaddress, self._realaddress)
                  def _createsymlink(self):
                      if self._baseaddress == self._realaddress:
                          return
                      tempaddress = _tempaddress(self._baseaddress)
                      os.symlink(os.path.basename(self._realaddress), tempaddress)
                      util.rename(tempaddress, self._baseaddress)
                  def _issocketowner(self):
                      try:
                          st = os.stat(self._realaddress)
                          return (
                              st.st_ino == self._socketstat.st_ino
                              and st[stat.ST_MTIME] == self._socketstat[stat.ST_MTIME]
                          )
                      except OSError:
                          return False
                  def unlinksocket(self, address):
                      if not self._issocketowner():
                          return
                      # it is possible to have a race condition here that we may
                      # remove another server's socket file. but that's okay
                      # since that server will detect and exit automatically and
                      # the client will start a new server on demand.
                      util.tryunlink(self._realaddress)
                  def shouldexit(self):
                      if not self._issocketowner():
                          self.ui.log(
                              b'chgserver', b'%s is not owned, exiting.\n', self._realaddress
                          )
                          return True
                      if time.time() - self._lastactive > self._idletimeout:
                          self.ui.log(b'chgserver', b'being idle too long. exiting.\n')
                          return True
                      return False
                  def newconnection(self):
                      self._lastactive = time.time()
                  def createcmdserver(self, repo, conn, fin, fout, prereposetups):
                      return chgcmdserver(
                          self.ui,
                          repo,
                          fin,
                          fout,
                          conn,
                          prereposetups,
                          self._hashstate,
                          self._baseaddress,
                      )
              def chgunixservice(ui, repo, opts):
                  # CHGINTERNALMARK is set by chg client. It is an indication of things are
                  # started by chg so other code can do things accordingly, like disabling
                  # demandimport or detecting chg client started by chg client. When executed
                  # here, CHGINTERNALMARK is no longer useful and hence dropped to make
                  # environ cleaner.
                  if b'CHGINTERNALMARK' in encoding.environ:
                      del encoding.environ[b'CHGINTERNALMARK']
                  # Python3.7+ "coerces" the LC_CTYPE environment variable to a UTF-8 one if
                  # it thinks the current value is "C". This breaks the hash computation and
                  # causes chg to restart loop.
                  if b'CHGORIG_LC_CTYPE' in encoding.environ:
                      encoding.environ[b'LC_CTYPE'] = encoding.environ[b'CHGORIG_LC_CTYPE']
                      del encoding.environ[b'CHGORIG_LC_CTYPE']
                  elif b'CHG_CLEAR_LC_CTYPE' in encoding.environ:
                      if b'LC_CTYPE' in encoding.environ:
                          del encoding.environ[b'LC_CTYPE']
                      del encoding.environ[b'CHG_CLEAR_LC_CTYPE']
                  if repo:
                      # one chgserver can serve multiple repos. drop repo information
                      ui.setconfig(b'bundle', b'mainreporoot', b'', b'repo')
                  h = chgunixservicehandler(ui)
                  return commandserver.unixforkingservice(ui, repo=None, opts=opts, handler=h)

tests/run-tests.py

0 +6 -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 distutils.version as version
              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`
              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()
              xrange = range  # we use xrange in one place, and we'd rather not use range
              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')
              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 socket.error as exc:
                      if WINDOWS and exc.errno == errno.WSAEACCES:
                          return False
                      # TODO: make a proper exception handler after dropping py2.  This
                      #       works because socket.error is an alias for OSError on py3,
                      #       which is also the baseclass of PermissionError.
                      elif isinstance(exc, PermissionError):
                          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 IOError as err:
                          if err.errno != errno.ENOENT:
                              raise
                          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 IOError as ex:
                      if ex.errno != errno.ENOENT:
                          raise
                  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 WINDOWS:
                      parser.error('--pyoxidized is currently 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
                          covver = version.StrictVersion(coverage.__version__).version
                          if covver < (3, 3):
                              parser.error('coverage options require coverage 3.3 or later')
                      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 OSError as e:
                          if e.errno != errno.EEXIST:
                              raise
                      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 OSError as e:
                              # We might have raced another test to clean up a .err
                              # file, so ignore ENOENT when removing a previous .err
                              # file.
                              if e.errno != errno.ENOENT:
                                  raise
                      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()
-                     env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or ''
+                     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 xrange(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
                      # True or False when in a true or false conditional section
                      skipping = None
                      # 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 not skipping:
                                  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')
                              if skipping is not None:
                                  after.setdefault(pos, []).append(b'  !!! nested #if\n')
                              skipping = not self._iftest(lsplit[1:])
                              after.setdefault(pos, []).append(l)
                          elif l.startswith(b'#else'):
                              if skipping is None:
                                  after.setdefault(pos, []).append(b'  !!! missing #if\n')
                              skipping = not skipping
                              after.setdefault(pos, []).append(l)
                          elif l.startswith(b'#endif'):
                              if skipping is None:
                                  after.setdefault(pos, []).append(b'  !!! missing #if\n')
                              skipping = None
                              after.setdefault(pos, []).append(l)
                          elif skipping:
                              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 skipping is not None:
                          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 xrange(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 xrange(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 IOError as err:
                      if err.errno != errno.ENOENT:
                          raise
                  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 OSError as e:
                                  if e.errno != errno.ENOENT:
                                      raise
                                  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)
                      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
                          bin_path = (
                              b'build/pyoxidizer/x86_64-pc-windows-msvc/release/app/hg.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]
                      # 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 OSError as e:
                              if e.errno != errno.EEXIST:
                                  raise
                          # 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)
                          if self.options.list_tests:
                              result = runner.listtests(suite)
                          else:
                              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()
                              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 xrange(100):
                              allfree = True
                              port = self.options.port + self._portoffset
                              for idx in xrange(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 OSError as err:
                                  if err.errno != errno.ENOENT:
                                      raise
                              if self._findprogram(pyexename) != sysexecutable:
                                  try:
                                      os.symlink(sysexecutable, mypython)
                                      self._createdfiles.append(mypython)
                                  except OSError as err:
                                      # child processes may race, which is harmless
                                      if err.errno != errno.EEXIST:
                                          raise
                      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 OSError as e:
                              if e.errno != errno.EEXIST:
                                  raise
                      makedirs(self._pythondir)
                      makedirs(self._bindir)
                      vlog("# Running", cmd.decode("utf-8"))
                      if subprocess.call(_bytes2sys(cmd), shell=True) == 0:
                          if not self.options.verbose:
                              try:
                                  os.remove(installerrs)
                              except OSError as e:
                                  if e.errno != errno.ENOENT:
                                      raise
                      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 OSError as e:
                              if e.errno != errno.EEXIST:
                                  raise
                          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()'
                      cmd = b'"%(make)s" pyoxidizer-windows-tests' % {
                          b'make': b'make',
                      }
                      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)
                  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:]))

tests/test-narrow-acl.t

0 +36 0

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

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