From 9baf334044dab90b4a0d096a7e456d0fd5807d5b Mon Sep 17 00:00:00 2001 From: David Worms Date: Thu, 18 Nov 2021 12:44:49 +0100 Subject: [PATCH] fix: dont insert polyfills in cjs #303 --- demo/issues-cjs/303.csv | 25001 +++++++++++++++++ demo/issues-cjs/303.js | 13 + demo/issues-cjs/package.json | 26 + demo/issues/package.json | 2 +- packages/csv-generate/dist/cjs/index.cjs | 5044 +--- packages/csv-generate/dist/cjs/sync.cjs | 5044 +--- packages/csv-generate/rollup.config.js | 30 +- packages/csv-parse/dist/cjs/index.cjs | 4992 +--- packages/csv-parse/dist/cjs/sync.cjs | 4990 +--- packages/csv-parse/rollup.config.js | 30 +- packages/csv-stringify/dist/cjs/index.cjs | 4980 +--- packages/csv-stringify/dist/cjs/sync.cjs | 4985 +--- packages/csv-stringify/rollup.config.js | 30 +- packages/csv/dist/cjs/index.cjs | 5090 +--- packages/csv/dist/cjs/sync.cjs | 5093 +--- packages/csv/dist/esm/index.js | 6 +- packages/csv/dist/esm/sync.js | 6 +- packages/csv/dist/iife/index.js | 6 +- packages/csv/dist/iife/sync.js | 6 +- packages/csv/dist/umd/index.js | 6 +- packages/csv/dist/umd/sync.js | 6 +- packages/csv/rollup.config.js | 30 +- packages/stream-transform/dist/cjs/index.cjs | 5044 +--- packages/stream-transform/dist/cjs/sync.cjs | 5044 +--- packages/stream-transform/rollup.config.js | 30 +- 25 files changed, 25301 insertions(+), 50233 deletions(-) create mode 100644 demo/issues-cjs/303.csv create mode 100644 demo/issues-cjs/303.js create mode 100644 demo/issues-cjs/package.json diff --git a/demo/issues-cjs/303.csv b/demo/issues-cjs/303.csv new file mode 100644 index 000000000..fa0bcc471 --- /dev/null +++ b/demo/issues-cjs/303.csv @@ -0,0 +1,25001 @@ +Index, Height, Weight +1, 65.78331, 112.9925 +2, 71.51521, 136.4873 +3, 69.39874, 153.0269 +4, 68.2166, 142.3354 +5, 67.78781, 144.2971 +6, 68.69784, 123.3024 +7, 69.80204, 141.4947 +8, 70.01472, 136.4623 +9, 67.90265, 112.3723 +10, 66.78236, 120.6672 +11, 66.48769, 127.4516 +12, 67.62333, 114.143 +13, 68.30248, 125.6107 +14, 67.11656, 122.4618 +15, 68.27967, 116.0866 +16, 71.0916, 139.9975 +17, 66.461, 129.5023 +18, 68.64927, 142.9733 +19, 71.23033, 137.9025 +20, 67.13118, 124.0449 +21, 67.83379, 141.2807 +22, 68.87881, 143.5392 +23, 63.48115, 97.90191 +24, 68.42187, 129.5027 +25, 67.62804, 141.8501 +26, 67.20864, 129.7244 +27, 70.84235, 142.4235 +28, 67.49434, 131.5502 +29, 66.53401, 108.3324 +30, 65.44098, 113.8922 +31, 69.5233, 103.3016 +32, 65.8132, 120.7536 +33, 67.8163, 125.7886 +34, 70.59505, 136.2225 +35, 71.80484, 140.1015 +36, 69.20613, 128.7487 +37, 66.80368, 141.7994 +38, 67.65893, 121.2319 +39, 67.80701, 131.3478 +40, 64.04535, 106.7115 +41, 68.57463, 124.3598 +42, 65.18357, 124.8591 +43, 69.65814, 139.6711 +44, 67.96731, 137.3696 +45, 65.98088, 106.4499 +46, 68.67249, 128.7639 +47, 66.88088, 145.6837 +48, 67.69868, 116.819 +49, 69.82117, 143.6215 +50, 69.08817, 134.9325 +51, 69.91479, 147.0219 +52, 67.33182, 126.3285 +53, 70.26939, 125.4839 +54, 69.10344, 115.7084 +55, 65.38356, 123.4892 +56, 70.18447, 147.8926 +57, 70.40617, 155.8987 +58, 66.54376, 128.0742 +59, 66.36418, 119.3701 +60, 67.537, 133.8148 +61, 66.50418, 128.7325 +62, 68.99958, 137.5453 +63, 68.30355, 129.7604 +64, 67.01255, 128.824 +65, 70.80592, 135.3165 +66, 68.21951, 109.6113 +67, 69.05914, 142.4684 +68, 67.73103, 132.749 +69, 67.21568, 103.5275 +70, 67.36763, 124.7299 +71, 65.27033, 129.3137 +72, 70.84278, 134.0175 +73, 69.92442, 140.3969 +74, 64.28508, 102.8351 +75, 68.2452, 128.5214 +76, 66.35708, 120.2991 +77, 68.36275, 138.6036 +78, 65.4769, 132.9574 +79, 69.71947, 115.6233 +80, 67.72554, 122.524 +81, 68.63941, 134.6254 +82, 66.78405, 121.8986 +83, 70.05147, 155.3767 +84, 66.27848, 128.9418 +85, 69.20198, 129.1013 +86, 69.13481, 139.4733 +87, 67.36436, 140.8901 +88, 70.09297, 131.5916 +89, 70.1766, 121.1232 +90, 68.22556, 131.5127 +91, 68.12932, 136.5479 +92, 70.24256, 141.4896 +93, 71.48752, 140.6104 +94, 69.20477, 112.1413 +95, 70.06306, 133.457 +96, 70.55703, 131.8001 +97, 66.28644, 120.0285 +98, 63.42577, 123.0972 +99, 66.76711, 128.1432 +100, 68.88741, 115.4759 +101, 64.87434, 102.0927 +102, 67.09272, 130.353 +103, 68.34761, 134.1842 +104, 65.61073, 98.64133 +105, 67.75551, 114.5599 +106, 68.0212, 123.4917 +107, 67.66193, 123.048 +108, 66.3146, 126.4772 +109, 69.43706, 128.417 +110, 63.83624, 127.1941 +111, 67.72277, 122.0562 +112, 70.05098, 127.6064 +113, 70.18602, 131.6423 +114, 65.94588, 111.8955 +115, 70.007, 122.039 +116, 68.61129, 128.5547 +117, 68.80817, 132.6792 +118, 69.76212, 136.0632 +119, 65.45539, 115.9403 +120, 68.82534, 136.9041 +121, 65.8003, 119.8804 +122, 67.21474, 109.0055 +123, 69.42021, 128.2705 +124, 68.94396, 135.2913 +125, 67.9415, 106.8558 +126, 65.62506, 123.2939 +127, 66.49607, 109.5143 +128, 67.92809, 119.3087 +129, 68.89415, 140.2402 +130, 70.241, 133.9841 +131, 68.26623, 132.5807 +132, 71.23161, 130.6988 +133, 69.09747, 115.5637 +134, 64.39693, 123.7941 +135, 71.09585, 128.1427 +136, 68.21868, 135.9646 +137, 65.91721, 116.6273 +138, 67.4369, 126.8241 +139, 73.90107, 151.3913 +140, 69.98149, 130.4022 +141, 69.51862, 136.2068 +142, 65.18437, 113.3989 +143, 68.00869, 125.3287 +144, 68.3384, 127.5846 +145, 65.18417, 107.1564 +146, 68.26209, 116.4588 +147, 68.56865, 133.8402 +148, 64.49675, 112.8901 +149, 68.71053, 130.7568 +150, 68.89148, 137.7571 +151, 69.54011, 125.4036 +152, 67.39964, 138.4659 +153, 66.47521, 120.8184 +154, 66.01217, 140.1539 +155, 72.44434, 136.7397 +156, 64.12642, 106.1139 +157, 70.98112, 158.9562 +158, 67.50124, 108.7868 +159, 72.01515, 138.7758 +160, 65.31143, 115.9136 +161, 67.07509, 146.2922 +162, 64.39148, 109.8765 +163, 69.37003, 139.0499 +164, 68.37921, 119.9001 +165, 65.31018, 128.3069 +166, 67.1369, 127.2428 +167, 68.39468, 115.2306 +168, 66.2918, 124.7975 +169, 67.1866, 126.9511 +170, 65.99156, 111.2711 +171, 69.43393, 122.6089 +172, 67.97463, 124.2084 +173, 67.76133, 124.6453 +174, 65.27864, 119.5169 +175, 73.83364, 139.2983 +176, 66.81312, 104.8265 +177, 66.89411, 123.0424 +178, 65.73568, 118.8923 +179, 65.98283, 121.4939 +180, 66.58396, 119.2488 +181, 67.11294, 135.0239 +182, 65.87481, 116.228 +183, 66.78067, 109.1731 +184, 68.73577, 124.2237 +185, 66.22666, 141.1645 +186, 65.95968, 129.1501 +187, 68.58372, 127.8693 +188, 66.59347, 120.9244 +189, 66.96574, 127.6466 +190, 68.08015, 101.4693 +191, 70.19025, 144.9927 +192, 65.52149, 110.9523 +193, 67.45905, 132.8625 +194, 67.40985, 146.3385 +195, 69.66158, 145.5894 +196, 65.79799, 120.8431 +197, 66.10558, 115.7813 +198, 68.23987, 128.3019 +199, 68.02403, 127.4718 +200, 71.39044, 127.8761 +201, 65.7316, 121.4997 +202, 66.43358, 112.7148 +203, 70.01309, 135.002 +204, 69.48146, 128.6789 +205, 68.62764, 124.4062 +206, 68.36275, 140.026 +207, 68.39028, 117.519 +208, 68.77413, 143.8737 +209, 69.9236, 141.1703 +210, 71.55542, 155.9414 +211, 68.44764, 134.0093 +212, 66.71398, 130.0975 +213, 66.68413, 106.2265 +214, 67.93699, 112.0489 +215, 68.89855, 136.1884 +216, 67.29191, 131.236 +217, 69.57212, 131.3231 +218, 67.67479, 119.5261 +219, 69.04155, 116.9965 +220, 67.96765, 138.5255 +221, 65.83982, 109.6518 +222, 65.77288, 130.1569 +223, 71.14106, 137.1114 +224, 67.83055, 113.759 +225, 65.0693, 114.9725 +226, 69.70745, 127.7149 +227, 69.92983, 121.9972 +228, 66.11569, 117.9607 +229, 68.61364, 127.7141 +230, 68.9976, 117.9619 +231, 66.79171, 125.1554 +232, 68.02363, 141.1026 +233, 69.67258, 145.4822 +234, 71.82178, 116.065 +235, 72.74676, 135.7458 +236, 67.27951, 132.9248 +237, 67.41015, 115.6622 +238, 68.5315, 114.3184 +239, 68.47126, 148.952 +240, 68.51867, 142.1878 +241, 63.72529, 134.104 +242, 67.70483, 141.8926 +243, 69.47115, 138.7444 +244, 66.70198, 134.449 +245, 65.23126, 117.0167 +246, 69.89473, 115.6752 +247, 69.83048, 134.7905 +248, 65.3979, 120.5746 +249, 68.32214, 120.0835 +250, 65.93895, 84.3598 +251, 70.09805, 138.9394 +252, 66.05531, 143.5245 +253, 68.23481, 123.1347 +254, 65.21758, 115.5261 +255, 69.16173, 120.9844 +256, 67.60064, 120.6473 +257, 67.28621, 124.0352 +258, 66.84323, 117.2238 +259, 68.08281, 127.9598 +260, 66.56991, 116.7527 +261, 70.16973, 121.9957 +262, 67.85113, 123.9952 +263, 66.62309, 108.855 +264, 63.68816, 104.6574 +265, 68.0356, 132.248 +266, 66.941, 127.1834 +267, 66.26292, 125.1209 +268, 70.7301, 133.322 +269, 70.70844, 122.3364 +270, 73.26872, 130.2636 +271, 63.79021, 116.7431 +272, 67.84109, 125.8534 +273, 67.78058, 100.627 +274, 67.23901, 118.4945 +275, 66.75701, 137.1255 +276, 69.03098, 118.6991 +277, 68.52652, 124.1641 +278, 64.65419, 124.9442 +279, 65.14295, 126.3889 +280, 66.74124, 121.5255 +281, 66.99923, 133.2951 +282, 70.26611, 127.4072 +283, 67.57666, 125.08 +284, 66.30582, 102.8114 +285, 68.90702, 134.2212 +286, 65.60543, 100.9758 +287, 68.00189, 145.8886 +288, 69.93715, 155.3046 +289, 70.1459, 138.7175 +290, 66.66364, 116.2611 +291, 69.40676, 120.6087 +292, 66.80598, 114.4083 +293, 67.70048, 133.3406 +294, 69.13438, 92.74955 +295, 67.53769, 131.7825 +296, 65.77912, 118.3865 +297, 66.25769, 131.1466 +298, 67.39038, 130.2033 +299, 64.94327, 129.1836 +300, 69.25699, 143.1445 +301, 69.07739, 138.7307 +302, 69.64403, 130.9528 +303, 69.07705, 124.3032 +304, 68.01304, 135.3702 +305, 68.85664, 124.1988 +306, 63.19158, 111.2389 +307, 65.57591, 129.4037 +308, 69.12101, 127.7444 +309, 69.78765, 121.3311 +310, 67.48203, 118.2183 +311, 69.08809, 123.3441 +312, 68.5529, 151.9118 +313, 68.21327, 115.3108 +314, 67.1012, 122.3844 +315, 71.23661, 129.2323 +316, 69.11946, 138.2824 +317, 65.49848, 144.0565 +318, 66.58706, 120.8482 +319, 67.99831, 113.3034 +320, 72.57747, 149.3227 +321, 67.97585, 130.6373 +322, 66.62347, 122.387 +323, 67.29574, 133.8677 +324, 65.95951, 134.8336 +325, 66.54011, 137.8363 +326, 68.07723, 112.6812 +327, 65.83291, 121.1964 +328, 69.23721, 114.9262 +329, 64.69413, 110.3762 +330, 69.21372, 126.0337 +331, 67.16792, 118.7008 +332, 67.8467, 119.3108 +333, 69.27389, 150.7397 +334, 67.90547, 121.1142 +335, 67.076, 118.4065 +336, 70.01531, 142.759 +337, 70.05454, 145.6305 +338, 70.86714, 127.3425 +339, 66.0586, 115.9678 +340, 65.23745, 104.4441 +341, 68.7413, 138.4905 +342, 69.51946, 145.5049 +343, 70.30764, 124.4065 +344, 67.29982, 124.1866 +345, 67.60582, 126.1659 +346, 67.85566, 138.8125 +347, 66.46536, 121.5515 +348, 68.92071, 114.2555 +349, 68.46886, 129.4022 +350, 69.5193, 137.5583 +351, 70.23956, 134.4996 +352, 67.85651, 127.7103 +353, 68.00435, 115.6709 +354, 67.13983, 131.5906 +355, 68.09931, 127.5839 +356, 68.99077, 125.7211 +357, 69.32618, 119.9885 +358, 70.09286, 140.8676 +359, 68.74304, 136.9164 +360, 64.18633, 118.4759 +361, 66.09074, 129.5516 +362, 69.24418, 152.0714 +363, 69.66512, 120.8646 +364, 68.42721, 136.1027 +365, 68.28613, 130.0611 +366, 69.37684, 131.7743 +367, 68.35315, 139.38 +368, 72.32489, 168.229 +369, 70.37159, 127.6446 +370, 65.72927, 131.8008 +371, 66.49627, 122.8561 +372, 70.81339, 140.2133 +373, 67.37579, 142.6929 +374, 67.79709, 137.4299 +375, 68.1607, 126.0392 +376, 68.85782, 143.5985 +377, 67.71342, 122.62 +378, 64.66007, 108.6044 +379, 65.73721, 100.6617 +380, 68.42441, 116.1397 +381, 68.88946, 140.5293 +382, 68.27367, 125.6907 +383, 69.18045, 134.3329 +384, 72.60996, 136.4649 +385, 66.04157, 127.8822 +386, 69.2288, 123.1361 +387, 68.87697, 116.3375 +388, 66.46042, 124.5581 +389, 69.30444, 125.7853 +390, 67.58249, 107.5905 +391, 69.41816, 143.0236 +392, 67.46867, 118.7434 +393, 66.44873, 118.9856 +394, 68.76185, 131.8744 +395, 63.76881, 119.3691 +396, 69.03663, 126.1223 +397, 66.48966, 126.6122 +398, 66.74224, 113.5597 +399, 67.69394, 115.8413 +400, 66.69066, 130.2738 +401, 67.02877, 125.4542 +402, 65.91096, 117.1655 +403, 70.0304, 137.3184 +404, 69.26978, 149.4447 +405, 70.07695, 151.0695 +406, 64.90942, 116.9994 +407, 69.68744, 138.1787 +408, 67.56524, 127.621 +409, 63.85529, 120.7514 +410, 71.6189, 144.2537 +411, 64.98993, 105.7939 +412, 64.60759, 120.1567 +413, 62.01666, 109.0848 +414, 65.28516, 125.971 +415, 67.70163, 110.2325 +416, 70.85794, 134.4706 +417, 68.17075, 115.5067 +418, 67.45006, 125.1086 +419, 71.04224, 116.4113 +420, 67.83032, 133.3944 +421, 67.15488, 108.7478 +422, 68.30289, 134.3986 +423, 65.41208, 131.2085 +424, 68.66755, 130.8318 +425, 70.06733, 127.0838 +426, 69.13413, 119.4067 +427, 67.02078, 105.5616 +428, 65.52274, 134.4733 +429, 70.19808, 132.6897 +430, 67.66866, 126.058 +431, 69.73257, 126.3532 +432, 67.61719, 142.3603 +433, 70.79589, 124.5873 +434, 69.65804, 122.3604 +435, 66.73277, 123.2298 +436, 67.58008, 131.4049 +437, 65.25317, 124.3037 +438, 70.71387, 128.3836 +439, 71.27374, 136.853 +440, 66.55913, 118.0569 +441, 68.04247, 121.4969 +442, 68.11699, 119.2811 +443, 71.2367, 126.5545 +444, 66.92387, 129.2477 +445, 71.10381, 134.7804 +446, 69.41466, 146.0725 +447, 69.16807, 162.4109 +448, 68.57725, 130.1885 +449, 69.60315, 132.1941 +450, 69.05087, 127.4591 +451, 68.28699, 125.3466 +452, 69.25276, 134.7559 +453, 68.23862, 121.9395 +454, 67.6868, 125.6688 +455, 68.84083, 145.956 +456, 69.52061, 119.9207 +457, 66.97668, 111.5093 +458, 72.0053, 138.676 +459, 67.44482, 135.0151 +460, 66.06214, 116.509 +461, 65.5747, 123.9575 +462, 68.30171, 136.952 +463, 71.02603, 153.0797 +464, 70.76882, 126.357 +465, 67.50812, 145.0614 +466, 69.50936, 135.1739 +467, 66.4455, 108.806 +468, 68.5689, 110.5155 +469, 67.01296, 138.2685 +470, 68.70004, 119.5111 +471, 68.23013, 115.3214 +472, 70.40713, 132.3684 +473, 65.69989, 93.99438 +474, 65.7031, 127.4051 +475, 68.48055, 134.3024 +476, 66.62891, 124.9721 +477, 66.84285, 124.072 +478, 69.89734, 133.5476 +479, 67.6543, 134.1509 +480, 68.30917, 130.2489 +481, 69.74848, 138.0935 +482, 68.57906, 126.6064 +483, 68.14477, 131.8076 +484, 67.98093, 131.7363 +485, 64.82535, 117.6261 +486, 69.20785, 126.1943 +487, 69.2656, 127.5132 +488, 70.9403, 142.4785 +489, 69.07826, 139.444 +490, 66.20183, 110.3204 +491, 71.05779, 131.9541 +492, 68.99493, 129.2037 +493, 70.96089, 124.3513 +494, 66.02496, 126.5251 +495, 69.8641, 149.2303 +496, 66.82802, 142.1577 +497, 69.09424, 127.1436 +498, 66.81425, 122.3353 +499, 67.13183, 112.6659 +500, 64.57428, 134.2647 +501, 68.68038, 120.6936 +502, 67.53724, 115.783 +503, 71.17732, 128.6855 +504, 70.53514, 134.7611 +505, 71.53411, 118.3419 +506, 66.77301, 106.1557 +507, 66.33636, 126.3823 +508, 64.83095, 114.3716 +509, 68.38247, 130.2787 +510, 68.05038, 123.3066 +511, 69.09149, 122.8571 +512, 69.91046, 125.6932 +513, 68.40737, 111.7247 +514, 68.32559, 125.5516 +515, 66.95555, 119.9702 +516, 70.54816, 132.6043 +517, 69.37805, 132.6738 +518, 67.52012, 117.4521 +519, 64.87142, 101.8549 +520, 69.13396, 128.4418 +521, 68.81192, 134.0414 +522, 67.56446, 127.7511 +523, 68.16772, 127.6172 +524, 65.80687, 139.3971 +525, 64.92276, 113.9381 +526, 68.35584, 147.5188 +527, 66.71546, 132.6523 +528, 69.18196, 132.8139 +529, 65.88795, 105.0942 +530, 66.03733, 127.5187 +531, 69.44194, 130.7305 +532, 67.14847, 128.5815 +533, 65.69442, 122.5699 +534, 69.42723, 157.2961 +535, 66.54503, 121.1097 +536, 69.04469, 147.5061 +537, 67.62036, 117.493 +538, 69.59105, 132.4472 +539, 68.12343, 118.1774 +540, 71.22641, 123.7319 +541, 66.43285, 130.365 +542, 66.31808, 122.8882 +543, 68.02724, 107.8693 +544, 68.2876, 118.591 +545, 66.91609, 125.6467 +546, 71.77546, 148.6016 +547, 66.04535, 150.279 +548, 69.01455, 127.0678 +549, 68.70744, 128.7122 +550, 65.012, 118.4233 +551, 66.05857, 125.3879 +552, 71.16403, 149.2676 +553, 67.55274, 107.3484 +554, 68.83455, 133.6992 +555, 68.11811, 124.8508 +556, 67.90528, 112.7028 +557, 67.64085, 127.8407 +558, 69.78282, 134.1615 +559, 67.99889, 138.6031 +560, 69.41465, 126.044 +561, 70.42989, 129.5856 +562, 67.67519, 134.1054 +563, 67.88036, 106.1251 +564, 68.06905, 127.0561 +565, 66.99435, 121.9241 +566, 71.57689, 150.7365 +567, 64.36564, 116.0061 +568, 67.93011, 125.4748 +569, 69.91863, 131.6099 +570, 69.93864, 129.0696 +571, 66.79766, 129.1117 +572, 70.11119, 148.1624 +573, 68.94814, 105.388 +574, 68.02886, 110.5447 +575, 69.36148, 118.6402 +576, 68.44886, 122.8151 +577, 65.70282, 124.887 +578, 69.55674, 135.7695 +579, 65.84635, 116.4563 +580, 68.79983, 125.3617 +581, 69.03835, 133.122 +582, 67.36352, 138.3328 +583, 70.35788, 124.4972 +584, 69.88828, 136.7205 +585, 65.15319, 115.0153 +586, 69.40907, 132.6366 +587, 68.50874, 143.1323 +588, 65.71552, 134.7422 +589, 63.98308, 122.6246 +590, 70.07685, 153.5634 +591, 68.42542, 126.289 +592, 68.23665, 134.7206 +593, 67.82856, 134.5987 +594, 66.31277, 118.3945 +595, 69.75128, 121.2997 +596, 65.70901, 132.2844 +597, 66.88227, 139.0617 +598, 67.2791, 110.698 +599, 70.63357, 154.1073 +600, 69.9377, 124.1592 +601, 65.87671, 134.5173 +602, 72.44694, 138.2622 +603, 70.07052, 149.0801 +604, 67.68486, 127.0075 +605, 66.1151, 117.8222 +606, 69.94355, 148.9096 +607, 68.24317, 128.2151 +608, 68.80144, 129.6944 +609, 66.61818, 125.5674 +610, 70.18701, 128.7947 +611, 65.58971, 124.187 +612, 68.69566, 151.4167 +613, 64.88639, 106.9803 +614, 69.81993, 145.6221 +615, 66.33962, 121.5926 +616, 70.4434, 130.9386 +617, 69.99163, 135.6203 +618, 70.13617, 123.9315 +619, 67.1793, 131.9955 +620, 68.2034, 117.484 +621, 67.76121, 129.6577 +622, 64.79753, 122.3706 +623, 66.47871, 114.5867 +624, 66.98337, 116.5401 +625, 65.69991, 139.4307 +626, 66.82705, 123.4822 +627, 66.35141, 132.5492 +628, 70.13491, 143.4013 +629, 70.11565, 132.9429 +630, 64.56145, 98.8972 +631, 68.15724, 122.4342 +632, 67.1475, 104.6767 +633, 70.88927, 142.7847 +634, 68.16218, 130.9283 +635, 71.19657, 143.827 +636, 67.92444, 142.2832 +637, 65.30204, 107.9441 +638, 66.40756, 105.6891 +639, 71.30647, 125.4007 +640, 69.05997, 106.4195 +641, 65.95442, 118.5371 +642, 69.63776, 136.7836 +643, 71.10495, 145.9328 +644, 66.21851, 129.637 +645, 66.13469, 108.4955 +646, 67.7851, 121.2537 +647, 66.67737, 135.7399 +648, 69.99408, 137.5026 +649, 71.1441, 124.0052 +650, 68.63927, 128.8613 +651, 69.08548, 133.6811 +652, 67.97389, 106.5185 +653, 65.94809, 113.0398 +654, 66.02102, 125.9639 +655, 71.23576, 140.2945 +656, 67.52674, 143.229 +657, 71.06935, 145.8063 +658, 68.27178, 128.1697 +659, 67.31932, 134.1839 +660, 68.98848, 140.2166 +661, 68.404, 146.3453 +662, 67.092, 132.0784 +663, 66.76866, 122.13 +664, 65.64636, 131.4693 +665, 65.34105, 129.5167 +666, 68.18299, 125.7451 +667, 70.65924, 153.1384 +668, 65.94401, 124.5559 +669, 69.62792, 134.8225 +670, 68.29965, 115.3877 +671, 70.06075, 117.9618 +672, 68.43602, 124.5647 +673, 69.27012, 134.4043 +674, 67.70511, 129.3092 +675, 70.89315, 133.1423 +676, 70.54313, 147.3609 +677, 71.58086, 155.0132 +678, 68.42301, 126.2905 +679, 69.35781, 134.4605 +680, 70.445, 134.0296 +681, 67.38153, 128.9248 +682, 67.50767, 123.0543 +683, 68.52054, 112.1788 +684, 66.80858, 111.7443 +685, 72.38532, 148.4615 +686, 68.51642, 136.7459 +687, 70.79791, 133.2068 +688, 66.21905, 116.8855 +689, 68.31167, 124.8542 +690, 67.1715, 121.5809 +691, 67.7714, 123.197 +692, 67.47328, 137.1255 +693, 67.77463, 121.4941 +694, 69.20099, 150.9398 +695, 70.04297, 142.3009 +696, 70.56979, 134.7527 +697, 66.45379, 133.5585 +698, 67.68132, 136.0895 +699, 65.75638, 95.20216 +700, 69.3549, 119.7404 +701, 70.5902, 152.9146 +702, 67.27626, 140.1991 +703, 68.48853, 145.2503 +704, 67.02188, 119.4855 +705, 65.77613, 123.512 +706, 65.96579, 110.6754 +707, 68.18868, 111.4951 +708, 72.08595, 139.4849 +709, 66.85358, 133.088 +710, 69.10929, 133.5196 +711, 64.5909, 112.7698 +712, 67.03849, 124.7975 +713, 68.99156, 123.4224 +714, 70.59872, 142.0921 +715, 70.08988, 116.2814 +716, 65.6844, 131.1256 +717, 67.0982, 131.2493 +718, 66.03932, 127.2422 +719, 69.26423, 122.4523 +720, 66.61351, 115.2431 +721, 68.11738, 126.9532 +722, 69.73059, 143.4439 +723, 64.02042, 125.377 +724, 66.23753, 109.0095 +725, 72.46761, 139.2411 +726, 66.21938, 102.182 +727, 71.2978, 144.3898 +728, 63.1255, 83.08527 +729, 70.93034, 145.3938 +730, 68.25489, 134.9267 +731, 64.78014, 134.678 +732, 65.42982, 111.4963 +733, 68.91361, 119.7951 +734, 64.96937, 95.70426 +735, 66.15237, 117.159 +736, 65.98386, 127.2356 +737, 69.2435, 144.9205 +738, 68.31982, 122.8464 +739, 70.11607, 134.19 +740, 68.63521, 124.9776 +741, 67.74289, 135.8441 +742, 64.58641, 120.8222 +743, 64.66165, 125.0174 +744, 65.90771, 133.5474 +745, 65.77649, 124.5583 +746, 67.1506, 135.9691 +747, 72.24339, 143.5738 +748, 68.73199, 130.5725 +749, 67.57019, 127.192 +750, 70.36234, 141.2372 +751, 63.62233, 107.4236 +752, 66.20711, 122.3234 +753, 66.22114, 111.6055 +754, 70.0722, 137.8915 +755, 69.6563, 142.8742 +756, 66.25043, 114.4349 +757, 68.0704, 128.2736 +758, 67.14808, 134.5725 +759, 68.76609, 140.1034 +760, 68.12075, 121.977 +761, 65.72987, 111.4248 +762, 69.17439, 135.0756 +763, 70.36351, 132.9826 +764, 70.78557, 117.7566 +765, 70.88083, 134.9877 +766, 66.62148, 151.6121 +767, 69.9829, 128.9287 +768, 66.92866, 120.1575 +769, 71.45806, 125.6007 +770, 69.66344, 127.8292 +771, 69.30943, 136.1354 +772, 66.59775, 116.2841 +773, 64.20209, 127.0777 +774, 68.23051, 125.7165 +775, 70.09021, 121.0749 +776, 70.9755, 122.7382 +777, 64.93134, 119.4545 +778, 66.90106, 132.9048 +779, 69.19803, 132.8687 +780, 68.4149, 124.3486 +781, 66.3163, 132.2198 +782, 72.13467, 142.804 +783, 65.74613, 129.605 +784, 69.96677, 128.5326 +785, 65.11417, 112.9919 +786, 67.43294, 122.0795 +787, 66.39785, 118.396 +788, 67.18769, 130.1299 +789, 67.68597, 111.6824 +790, 67.77469, 142.2452 +791, 63.62937, 122.6049 +792, 66.447, 122.8198 +793, 71.9233, 119.1123 +794, 67.92214, 139.4335 +795, 68.01143, 141.3353 +796, 67.76524, 119.787 +797, 69.19791, 136.326 +798, 67.00109, 118.4099 +799, 67.09659, 137.692 +800, 69.85144, 129.078 +801, 67.42782, 123.4642 +802, 68.1104, 115.4311 +803, 68.29433, 129.931 +804, 69.45176, 135.9563 +805, 69.08219, 127.8134 +806, 70.91753, 139.1014 +807, 64.20566, 109.2132 +808, 71.10315, 124.6154 +809, 72.08523, 136.221 +810, 66.15119, 120.4722 +811, 67.52898, 116.1659 +812, 67.17586, 115.5093 +813, 72.92955, 141.9961 +814, 65.54112, 135.4869 +815, 69.08487, 135.1305 +816, 65.28991, 108.2494 +817, 68.53447, 125.1277 +818, 71.32802, 142.8947 +819, 66.88095, 128.2978 +820, 67.91196, 128.268 +821, 67.00238, 103.5665 +822, 68.27584, 156.1069 +823, 66.20276, 104.9661 +824, 64.24214, 121.6365 +825, 67.43738, 132.0066 +826, 64.50081, 118.4079 +827, 68.89607, 135.3898 +828, 70.32908, 140.6633 +829, 64.31742, 111.6703 +830, 67.11253, 128.0328 +831, 68.01206, 130.4737 +832, 68.25267, 128.2127 +833, 67.76873, 142.8202 +834, 67.44291, 123.0804 +835, 65.73581, 117.8771 +836, 69.64372, 130.9274 +837, 71.92818, 129.1735 +838, 69.39435, 144.5784 +839, 67.14717, 115.8635 +840, 69.1469, 116.5322 +841, 66.90594, 141.9947 +842, 67.838, 132.1304 +843, 68.09614, 135.2607 +844, 66.14093, 127.0684 +845, 71.16386, 129.844 +846, 67.55757, 134.5066 +847, 70.01279, 121.3609 +848, 72.56431, 143.1486 +849, 66.60224, 124.7741 +850, 68.51802, 120.1546 +851, 66.34638, 139.4163 +852, 69.02692, 131.6743 +853, 69.12446, 131.07 +854, 68.24578, 129.8914 +855, 68.4869, 123.344 +856, 70.68261, 137.5314 +857, 70.35969, 136.8886 +858, 67.62401, 118.4024 +859, 69.4463, 116.2441 +860, 67.92486, 124.8433 +861, 68.39347, 120.9809 +862, 66.31812, 105.1208 +863, 71.22882, 145.4377 +864, 65.29169, 108.1912 +865, 66.00287, 130.3778 +866, 67.61775, 117.5157 +867, 69.10276, 135.8762 +868, 68.99743, 127.5126 +869, 69.07531, 151.3998 +870, 68.34086, 112.4799 +871, 71.68196, 156.7554 +872, 68.77664, 138.2098 +873, 66.18191, 109.5685 +874, 72.37092, 139.9742 +875, 66.85155, 124.5873 +876, 65.75688, 130.5023 +877, 69.69245, 151.0783 +878, 66.27915, 108.7722 +879, 66.47752, 105.9927 +880, 68.71912, 143.4301 +881, 68.29244, 114.7434 +882, 67.66696, 123.7736 +883, 71.29885, 139.4769 +884, 67.07369, 115.8201 +885, 70.68048, 146.5682 +886, 71.40114, 153.9993 +887, 71.00392, 137.5899 +888, 66.2799, 125.9287 +889, 68.05383, 139.6939 +890, 64.16346, 126.3585 +891, 66.87966, 113.9307 +892, 70.52968, 129.7605 +893, 65.45595, 116.1925 +894, 69.11331, 139.1294 +895, 67.94221, 126.9815 +896, 67.2132, 125.8352 +897, 67.6372, 113.524 +898, 70.09365, 123.2372 +899, 64.41354, 123.0554 +900, 69.77698, 128.133 +901, 66.58181, 127.9357 +902, 68.14995, 110.4678 +903, 66.18165, 127.9364 +904, 66.79412, 118.1678 +905, 67.1657, 129.7243 +906, 68.01904, 130.6094 +907, 66.95837, 105.0414 +908, 68.70397, 122.6299 +909, 69.68057, 138.3259 +910, 66.52793, 107.7381 +911, 66.46981, 141.4417 +912, 71.44643, 153.6966 +913, 66.62648, 134.5551 +914, 64.01015, 109.6593 +915, 65.03312, 117.2029 +916, 66.77216, 124.2843 +917, 68.91932, 125.2193 +918, 71.22926, 133.2256 +919, 71.10332, 122.6042 +920, 69.80699, 134.8652 +921, 67.09127, 111.4506 +922, 67.27958, 116.8458 +923, 71.86593, 143.1527 +924, 67.20197, 99.92383 +925, 68.44108, 127.9232 +926, 67.20278, 136.658 +927, 69.36588, 145.3947 +928, 69.0416, 126.6818 +929, 65.9056, 128.1983 +930, 66.44766, 122.8328 +931, 66.08009, 133.2571 +932, 69.35367, 116.7606 +933, 70.83359, 144.0455 +934, 67.664, 132.5153 +935, 65.30966, 123.9832 +936, 66.66817, 113.1423 +937, 66.93271, 123.9512 +938, 67.73938, 133.9787 +939, 64.27722, 128.1519 +940, 66.83442, 121.2878 +941, 65.89728, 122.7107 +942, 67.6564, 125.4136 +943, 68.68966, 124.8761 +944, 66.08003, 116.5903 +945, 66.91344, 129.889 +946, 69.48392, 123.889 +947, 68.60001, 137.6571 +948, 69.21225, 130.8805 +949, 67.63342, 141.9706 +950, 65.73405, 125.7334 +951, 66.09947, 104.4108 +952, 67.65293, 117.0685 +953, 67.59619, 131.7669 +954, 69.57859, 125.4738 +955, 66.08879, 129.5734 +956, 70.08026, 130.1053 +957, 65.00956, 131.9305 +958, 69.16464, 142.4645 +959, 69.61276, 127.6431 +960, 71.48367, 153.3153 +961, 69.47413, 126.7609 +962, 69.0027, 114.0258 +963, 69.5581, 133.9684 +964, 68.63746, 127.5869 +965, 67.20262, 126.4859 +966, 66.07614, 120.7651 +967, 66.18342, 126.6479 +968, 70.80778, 133.0747 +969, 67.158, 125.9649 +970, 65.2973, 121.3206 +971, 69.23494, 129.7824 +972, 68.90768, 130.0549 +973, 72.3478, 123.4005 +974, 68.29557, 137.2791 +975, 68.34735, 127.7554 +976, 67.46476, 133.6853 +977, 68.86803, 113.9275 +978, 66.62471, 135.6168 +979, 64.77193, 122.6005 +980, 67.70647, 118.9472 +981, 72.992, 134.2703 +982, 70.95194, 124.2747 +983, 67.95677, 130.6981 +984, 67.20959, 124.6797 +985, 66.36959, 129.0839 +986, 67.63896, 121.9456 +987, 69.74444, 126.2689 +988, 68.17532, 134.6122 +989, 66.89711, 131.8476 +990, 67.4966, 103.5828 +991, 66.51569, 116.3925 +992, 66.88332, 123.5095 +993, 69.7277, 150.3395 +994, 69.78345, 135.2437 +995, 65.40046, 112.4584 +996, 67.99831, 137.4861 +997, 72.25581, 132.7902 +998, 70.79562, 126.0286 +999, 65.18786, 141.3591 +1000, 67.7123, 135.9065 +1001, 70.05146, 134.6655 +1002, 67.30497, 122.0232 +1003, 66.39813, 128.3502 +1004, 69.73637, 130.6354 +1005, 68.71659, 131.717 +1006, 63.88437, 108.6132 +1007, 68.40851, 114.5673 +1008, 67.93251, 133.5136 +1009, 70.69674, 135.8641 +1010, 68.95083, 148.1093 +1011, 66.49457, 123.5179 +1012, 68.59369, 120.8406 +1013, 66.26442, 116.2666 +1014, 69.58656, 123.8986 +1015, 67.35651, 119.32 +1016, 69.68727, 119.4097 +1017, 68.44046, 124.5933 +1018, 68.47973, 130.8802 +1019, 65.45463, 118.2058 +1020, 66.8085, 109.6357 +1021, 70.05212, 140.2298 +1022, 67.43558, 121.5764 +1023, 66.54306, 98.30262 +1024, 67.32353, 117.6173 +1025, 67.9725, 136.5104 +1026, 69.03858, 148.9791 +1027, 67.69453, 123.9665 +1028, 69.30508, 133.5957 +1029, 65.39643, 117.2334 +1030, 68.35638, 123.5943 +1031, 65.36888, 117.7674 +1032, 68.36499, 137.2321 +1033, 71.15702, 129.1996 +1034, 69.25532, 142.4032 +1035, 66.6984, 128.4838 +1036, 69.17548, 115.3008 +1037, 68.31559, 119.5309 +1038, 67.81616, 121.7224 +1039, 68.56123, 142.8442 +1040, 66.23085, 110.1171 +1041, 68.95099, 122.0958 +1042, 67.86761, 124.8188 +1043, 68.05498, 119.3169 +1044, 67.73986, 132.4571 +1045, 69.83641, 133.0316 +1046, 70.68574, 160.8831 +1047, 64.54385, 119.127 +1048, 67.93112, 138.516 +1049, 67.77291, 124.8232 +1050, 69.41312, 135.9744 +1051, 67.77213, 116.2254 +1052, 67.79965, 139.2002 +1053, 67.98313, 137.983 +1054, 69.97983, 144.5084 +1055, 63.83261, 109.1938 +1056, 65.57212, 127.228 +1057, 69.34307, 124.5517 +1058, 67.28398, 114.926 +1059, 68.7435, 132.5027 +1060, 69.03112, 125.3892 +1061, 69.64426, 128.4988 +1062, 66.70052, 117.7319 +1063, 67.9143, 112.9531 +1064, 64.36849, 126.1835 +1065, 65.87507, 118.7934 +1066, 67.07427, 125.4388 +1067, 69.34545, 124.9451 +1068, 69.83212, 145.5139 +1069, 66.10245, 116.7836 +1070, 69.26205, 132.5216 +1071, 68.33525, 114.8933 +1072, 69.38017, 122.8594 +1073, 69.12887, 130.5782 +1074, 68.44658, 119.1058 +1075, 66.34542, 133.8204 +1076, 70.03275, 128.5779 +1077, 70.16523, 139.0179 +1078, 68.18324, 101.2876 +1079, 70.12378, 140.958 +1080, 68.4296, 134.6146 +1081, 66.43974, 129.9482 +1082, 71.72703, 139.064 +1083, 70.72387, 135.1996 +1084, 68.09022, 129.682 +1085, 70.12976, 129.1395 +1086, 66.05393, 129.0051 +1087, 69.77059, 112.7357 +1088, 68.15816, 126.1123 +1089, 69.91372, 118.3724 +1090, 65.34461, 122.9731 +1091, 68.35621, 130.3663 +1092, 64.50585, 114.226 +1093, 67.95491, 115.7854 +1094, 68.57621, 137.9526 +1095, 68.12257, 112.2435 +1096, 68.77583, 137.237 +1097, 67.92593, 124.9418 +1098, 69.1484, 135.0961 +1099, 63.20539, 114.4199 +1100, 69.2442, 122.1823 +1101, 65.88645, 129.375 +1102, 67.85186, 129.9448 +1103, 65.57418, 140.4557 +1104, 66.70819, 120.8977 +1105, 69.172, 129.159 +1106, 69.23593, 137.1397 +1107, 67.57232, 145.2218 +1108, 69.50518, 140.0956 +1109, 70.60288, 124.12 +1110, 66.54152, 135.6875 +1111, 69.11494, 127.756 +1112, 69.951, 144.0475 +1113, 67.70347, 131.9333 +1114, 69.19028, 135.5263 +1115, 67.8047, 151.3579 +1116, 67.62532, 124.7073 +1117, 70.36898, 135.274 +1118, 71.02595, 136.5388 +1119, 69.8452, 137.8778 +1120, 67.08638, 114.2066 +1121, 68.62013, 141.5844 +1122, 64.37275, 111.0969 +1123, 65.93523, 126.3868 +1124, 65.24285, 132.8885 +1125, 70.51481, 144.7904 +1126, 66.61129, 108.3859 +1127, 67.13394, 124.1348 +1128, 66.77634, 129.4462 +1129, 67.69385, 131.3339 +1130, 67.82809, 111.6411 +1131, 66.63254, 111.6422 +1132, 67.62229, 140.3178 +1133, 69.66798, 125.5286 +1134, 62.75039, 114.49 +1135, 64.53878, 113.998 +1136, 68.01929, 117.1931 +1137, 66.38551, 138.3156 +1138, 70.18724, 122.3712 +1139, 64.646, 132.9431 +1140, 67.48819, 124.0449 +1141, 72.01807, 144.1591 +1142, 66.61356, 115.4581 +1143, 65.81803, 116.5192 +1144, 71.16185, 139.6139 +1145, 68.51977, 133.2364 +1146, 64.96088, 120.025 +1147, 66.88268, 123.1111 +1148, 70.3531, 132.8462 +1149, 67.71744, 120.9359 +1150, 66.03333, 129.7702 +1151, 68.9826, 136.9118 +1152, 68.60237, 131.121 +1153, 66.8408, 133.484 +1154, 68.03659, 136.3871 +1155, 64.79586, 131.4559 +1156, 70.55126, 126.1986 +1157, 68.28166, 115.046 +1158, 68.77574, 130.3178 +1159, 67.09315, 131.6954 +1160, 70.14303, 135.6519 +1161, 65.46833, 120.3029 +1162, 69.02275, 129.1442 +1163, 74.24899, 150.2167 +1164, 64.08575, 120.2076 +1165, 67.57977, 132.153 +1166, 69.19395, 132.1247 +1167, 64.48615, 119.5029 +1168, 68.75888, 136.7629 +1169, 68.45184, 147.7846 +1170, 66.44205, 145.5992 +1171, 70.1756, 124.9662 +1172, 67.1386, 127.902 +1173, 66.91548, 125.9147 +1174, 68.63357, 109.6821 +1175, 66.95697, 107.7733 +1176, 69.97351, 134.1099 +1177, 66.92568, 134.901 +1178, 68.76347, 139.6364 +1179, 67.40692, 127.0273 +1180, 65.74615, 134.7717 +1181, 65.88357, 99.97124 +1182, 66.77623, 129.4522 +1183, 66.9622, 129.3592 +1184, 63.46642, 103.6594 +1185, 68.35224, 115.7327 +1186, 64.43147, 104.8874 +1187, 63.52175, 131.0054 +1188, 66.86196, 129.0709 +1189, 65.53651, 102.5494 +1190, 71.82306, 133.2257 +1191, 68.86538, 146.3008 +1192, 70.79207, 140.8125 +1193, 69.02139, 132.4618 +1194, 67.3527, 118.8437 +1195, 66.3294, 133.4495 +1196, 67.75792, 134.882 +1197, 68.64796, 129.6789 +1198, 68.18784, 136.7318 +1199, 71.53978, 133.9981 +1200, 68.58959, 128.1324 +1201, 71.33959, 130.2482 +1202, 67.18757, 130.2934 +1203, 67.70033, 128.3208 +1204, 64.13048, 134.0501 +1205, 69.90087, 140.5808 +1206, 66.72044, 115.1936 +1207, 69.3532, 135.8445 +1208, 69.70788, 142.8508 +1209, 67.73755, 143.0931 +1210, 68.16879, 114.9519 +1211, 71.94697, 149.4261 +1212, 67.37481, 132.0558 +1213, 65.34039, 127.0174 +1214, 65.63768, 103.3615 +1215, 68.91559, 125.3216 +1216, 65.44571, 130.6423 +1217, 68.11726, 124.3662 +1218, 69.52284, 140.6019 +1219, 69.40202, 124.229 +1220, 70.00803, 132.9642 +1221, 68.59817, 130.2067 +1222, 64.76508, 106.6241 +1223, 67.52805, 108.9888 +1224, 66.71974, 109.9473 +1225, 67.94808, 124.363 +1226, 69.09682, 131.5021 +1227, 70.04724, 137.4264 +1228, 67.92097, 116.0228 +1229, 67.99135, 117.9061 +1230, 68.92023, 116.7259 +1231, 66.75149, 115.4633 +1232, 68.07152, 129.9734 +1233, 68.75961, 148.9128 +1234, 70.93048, 126.0818 +1235, 68.29873, 115.4952 +1236, 69.25316, 158.7833 +1237, 68.39327, 141.2064 +1238, 68.48007, 129.838 +1239, 69.47286, 137.0682 +1240, 66.33003, 123.2428 +1241, 66.88679, 117.9651 +1242, 65.20091, 102.4998 +1243, 68.37273, 130.6338 +1244, 67.10601, 144.6224 +1245, 62.64242, 100.1982 +1246, 69.06906, 120.2937 +1247, 71.15727, 144.3108 +1248, 68.93324, 114.8805 +1249, 68.10686, 141.5328 +1250, 64.45765, 114.6963 +1251, 65.96736, 121.6607 +1252, 68.73038, 119.3241 +1253, 70.53564, 135.206 +1254, 67.40711, 115.9409 +1255, 66.11309, 123.2264 +1256, 69.47433, 133.0619 +1257, 70.95476, 136.3442 +1258, 65.56715, 124.1401 +1259, 65.49243, 116.2944 +1260, 68.89342, 133.1669 +1261, 67.59755, 137.941 +1262, 66.1724, 133.3173 +1263, 68.70371, 114.2219 +1264, 65.47651, 137.6516 +1265, 67.72604, 131.5375 +1266, 70.02202, 137.2221 +1267, 69.72107, 135.1331 +1268, 67.90954, 113.9257 +1269, 65.61306, 132.5883 +1270, 71.40631, 133.5753 +1271, 66.27843, 106.7793 +1272, 65.0276, 95.18466 +1273, 65.68922, 114.2675 +1274, 66.85743, 126.4804 +1275, 68.23, 126.7087 +1276, 66.12036, 110.9096 +1277, 71.32591, 132.3678 +1278, 70.2075, 133.7174 +1279, 71.03619, 144.0125 +1280, 68.18528, 129.9098 +1281, 68.99195, 106.5697 +1282, 67.95745, 121.9433 +1283, 69.49971, 118.1623 +1284, 67.12538, 106.6739 +1285, 67.75678, 128.444 +1286, 67.67958, 127.4595 +1287, 64.71984, 102.93 +1288, 69.72873, 127.8299 +1289, 68.50234, 139.7868 +1290, 70.56446, 133.2813 +1291, 66.58715, 120.2949 +1292, 63.80202, 102.4047 +1293, 66.38836, 134.2056 +1294, 66.7895, 121.4804 +1295, 66.99003, 108.2574 +1296, 72.61998, 145.8469 +1297, 67.80601, 114.9258 +1298, 68.63913, 124.6757 +1299, 65.81803, 113.619 +1300, 66.5755, 126.2651 +1301, 66.40067, 124.0382 +1302, 66.75992, 120.554 +1303, 69.02475, 124.4235 +1304, 70.24902, 130.1726 +1305, 70.18308, 137.2733 +1306, 67.63509, 126.9051 +1307, 66.43547, 118.2885 +1308, 67.50559, 119.6817 +1309, 68.19559, 134.332 +1310, 66.32293, 120.0364 +1311, 70.33673, 140.2713 +1312, 67.9766, 139.4025 +1313, 66.07451, 105.1086 +1314, 68.00118, 140.3289 +1315, 65.48497, 139.7691 +1316, 66.99532, 118.4896 +1317, 69.89331, 121.8301 +1318, 68.03229, 130.3482 +1319, 70.00989, 138.2214 +1320, 66.91337, 119.9847 +1321, 71.43101, 141.5275 +1322, 64.42386, 128.0746 +1323, 68.63254, 122.6639 +1324, 70.14808, 135.5841 +1325, 69.94628, 158.7993 +1326, 66.40808, 103.1971 +1327, 65.27161, 122.9332 +1328, 67.02796, 119.343 +1329, 66.333, 139.5722 +1330, 70.05322, 124.1145 +1331, 71.49315, 132.5483 +1332, 67.11911, 116.0712 +1333, 72.52115, 162.8737 +1334, 68.59945, 131.1394 +1335, 66.72202, 124.8745 +1336, 68.33163, 123.738 +1337, 66.52804, 119.0115 +1338, 69.80841, 135.4606 +1339, 70.18855, 139.6563 +1340, 67.70646, 120.3449 +1341, 66.73552, 113.0404 +1342, 68.37589, 115.658 +1343, 68.14008, 128.6282 +1344, 65.33269, 96.52385 +1345, 68.27634, 122.6695 +1346, 69.17767, 129.3968 +1347, 66.47919, 128.8422 +1348, 66.27731, 133.0853 +1349, 67.80211, 130.1248 +1350, 72.66613, 138.9119 +1351, 70.62111, 138.9252 +1352, 67.45131, 105.9085 +1353, 68.51925, 135.4393 +1354, 72.05853, 147.3129 +1355, 64.71472, 108.7636 +1356, 66.49054, 128.9625 +1357, 71.9151, 147.7867 +1358, 68.37932, 128.5716 +1359, 69.44208, 127.4285 +1360, 65.67788, 128.9123 +1361, 67.97944, 123.3621 +1362, 68.18702, 122.0501 +1363, 67.96766, 159.6644 +1364, 67.69418, 121.5022 +1365, 66.85727, 124.3686 +1366, 68.50423, 130.5608 +1367, 66.46892, 117.7781 +1368, 70.53609, 147.1473 +1369, 68.60163, 128.6512 +1370, 67.13712, 115.6854 +1371, 63.82574, 104.102 +1372, 67.39413, 122.4406 +1373, 71.3131, 124.6131 +1374, 67.98003, 100.4089 +1375, 67.8037, 131.8038 +1376, 71.05584, 134.7575 +1377, 70.6785, 148.5516 +1378, 69.45454, 151.3435 +1379, 67.75404, 121.4032 +1380, 66.37759, 132.7138 +1381, 66.90907, 118.1243 +1382, 67.36022, 120.412 +1383, 70.03559, 141.4458 +1384, 74.19488, 129.0597 +1385, 68.44192, 129.3121 +1386, 68.86465, 148.5716 +1387, 66.41874, 112.319 +1388, 68.58215, 130.0932 +1389, 69.01529, 123.1712 +1390, 64.12752, 99.36058 +1391, 72.58824, 139.1404 +1392, 69.53845, 131.9771 +1393, 69.32255, 127.7025 +1394, 67.26117, 136.8449 +1395, 68.8089, 126.4916 +1396, 65.83333, 111.1847 +1397, 69.14631, 128.5255 +1398, 66.76436, 123.1419 +1399, 68.10866, 141.374 +1400, 66.52579, 127.0178 +1401, 66.72267, 118.0513 +1402, 66.66847, 115.3536 +1403, 66.13808, 136.9275 +1404, 68.04169, 126.5685 +1405, 67.37032, 129.216 +1406, 68.37927, 142.1694 +1407, 68.64261, 136.578 +1408, 67.06567, 121.962 +1409, 69.29222, 146.9053 +1410, 69.97624, 142.657 +1411, 68.36664, 140.2292 +1412, 68.2079, 109.8398 +1413, 67.34824, 134.8916 +1414, 65.91384, 127.6066 +1415, 67.37608, 108.9719 +1416, 70.77374, 138.4284 +1417, 72.8469, 151.4509 +1418, 64.95583, 130.0036 +1419, 68.67514, 113.0897 +1420, 68.73548, 129.1464 +1421, 67.33471, 133.1919 +1422, 66.68746, 124.866 +1423, 65.85168, 121.4815 +1424, 70.81582, 137.8631 +1425, 65.09564, 125.8314 +1426, 70.61931, 135.3299 +1427, 67.96031, 107.3931 +1428, 70.68803, 144.1915 +1429, 66.34093, 100.5991 +1430, 71.98092, 130.1721 +1431, 70.17314, 140.8988 +1432, 70.63179, 143.6734 +1433, 64.87469, 90.29334 +1434, 69.62426, 130.4148 +1435, 65.17407, 123.8754 +1436, 69.09608, 154.0757 +1437, 71.81975, 137.4948 +1438, 68.66104, 141.8174 +1439, 67.17895, 126.8401 +1440, 68.00257, 131.9545 +1441, 70.77144, 120.9803 +1442, 68.82564, 119.7816 +1443, 70.04554, 127.7472 +1444, 68.95339, 134.2469 +1445, 64.41355, 108.5235 +1446, 63.82854, 125.0611 +1447, 68.3559, 123.0197 +1448, 69.25516, 129.8861 +1449, 73.38109, 154.8178 +1450, 69.36199, 151.9248 +1451, 70.71977, 135.6969 +1452, 67.59075, 127.2047 +1453, 70.98644, 137.876 +1454, 67.73825, 124.4771 +1455, 71.10527, 154.6002 +1456, 71.95975, 134.0699 +1457, 65.74155, 117.4639 +1458, 65.64344, 128.3519 +1459, 68.37038, 118.1031 +1460, 70.50701, 127.8238 +1461, 66.43263, 129.914 +1462, 66.60278, 131.3221 +1463, 68.03472, 128.1544 +1464, 69.83384, 122.8347 +1465, 68.22043, 143.5868 +1466, 67.78035, 106.5681 +1467, 67.1894, 124.9457 +1468, 66.17013, 113.6761 +1469, 65.98555, 105.4988 +1470, 70.37458, 125.3804 +1471, 66.98272, 120.0159 +1472, 69.07135, 135.0513 +1473, 64.39778, 112.0501 +1474, 70.30031, 126.6445 +1475, 68.46686, 126.7371 +1476, 68.07287, 138.6844 +1477, 69.65267, 143.346 +1478, 67.85116, 124.6758 +1479, 68.81195, 119.2154 +1480, 68.88093, 129.5162 +1481, 71.2914, 141.2136 +1482, 64.93822, 124.9304 +1483, 64.39593, 117.6936 +1484, 67.61191, 128.117 +1485, 65.36431, 125.507 +1486, 68.57192, 139.9115 +1487, 69.63015, 132.5572 +1488, 64.66196, 129.5233 +1489, 71.18005, 139.3905 +1490, 65.6959, 121.712 +1491, 66.05318, 122.7607 +1492, 67.04924, 117.4026 +1493, 68.42541, 135.9146 +1494, 68.54306, 123.838 +1495, 65.95454, 102.8468 +1496, 66.95297, 119.3281 +1497, 64.91704, 104.4281 +1498, 66.59452, 129.2376 +1499, 68.17706, 138.2296 +1500, 69.573, 138.6461 +1501, 71.65878, 130.4121 +1502, 65.06775, 124.4317 +1503, 66.85523, 127.9011 +1504, 67.84366, 125.2683 +1505, 69.22848, 121.1672 +1506, 69.75159, 128.1437 +1507, 67.48764, 121.494 +1508, 68.12465, 129.3746 +1509, 68.50207, 127.4765 +1510, 67.50188, 113.1406 +1511, 68.83511, 132.5812 +1512, 65.40895, 110.5741 +1513, 68.31175, 139.194 +1514, 68.78411, 128.757 +1515, 65.39974, 132.9714 +1516, 66.754, 125.0153 +1517, 65.37482, 95.80713 +1518, 70.65043, 152.9084 +1519, 70.97634, 121.217 +1520, 66.75895, 127.448 +1521, 66.26857, 120.2754 +1522, 67.34174, 127.4945 +1523, 67.39093, 111.026 +1524, 71.04158, 153.5447 +1525, 63.7418, 110.9415 +1526, 66.91954, 121.0967 +1527, 65.84956, 123.5086 +1528, 67.03723, 116.363 +1529, 67.92717, 134.9384 +1530, 66.72742, 113.8451 +1531, 66.34696, 113.0531 +1532, 66.53015, 127.5692 +1533, 68.60951, 125.1506 +1534, 66.11208, 115.4493 +1535, 67.01143, 138.9409 +1536, 70.45763, 133.292 +1537, 65.3277, 130.5079 +1538, 67.28212, 114.2578 +1539, 70.37548, 137.6167 +1540, 68.04608, 114.5218 +1541, 70.36839, 139.4884 +1542, 68.38089, 124.6962 +1543, 67.78852, 130.045 +1544, 69.77907, 141.782 +1545, 69.59613, 125.4556 +1546, 67.9806, 119.1796 +1547, 65.84256, 107.0361 +1548, 66.99247, 125.3591 +1549, 63.54764, 115.7565 +1550, 71.50943, 128.7986 +1551, 69.94093, 129.3747 +1552, 71.21029, 145.662 +1553, 71.56281, 123.6062 +1554, 65.31159, 124.6278 +1555, 65.18491, 122.7439 +1556, 65.25283, 120.2892 +1557, 67.46596, 128.6295 +1558, 67.27426, 111.5271 +1559, 64.97376, 117.7437 +1560, 64.60687, 109.4645 +1561, 69.736, 132.9405 +1562, 67.7749, 124.1881 +1563, 69.30528, 136.8094 +1564, 71.38338, 143.1901 +1565, 65.60915, 117.3002 +1566, 66.23041, 130.8166 +1567, 66.53307, 137.4417 +1568, 67.51649, 128.97 +1569, 67.72325, 114.6422 +1570, 68.57113, 138.4685 +1571, 66.23808, 123.19 +1572, 67.75308, 121.9934 +1573, 68.2829, 149.3778 +1574, 68.40175, 137.21 +1575, 66.09433, 138.6653 +1576, 70.03545, 118.8309 +1577, 65.46717, 116.7297 +1578, 66.46693, 131.5675 +1579, 67.85512, 129.5762 +1580, 70.36596, 131.4946 +1581, 68.09483, 125.1984 +1582, 70.06267, 131.8467 +1583, 67.65661, 121.0286 +1584, 69.08508, 121.8685 +1585, 68.40932, 147.9118 +1586, 69.12972, 130.6309 +1587, 67.97094, 139.9751 +1588, 67.62895, 126.6522 +1589, 66.80442, 116.7992 +1590, 68.57388, 132.4308 +1591, 67.45375, 130.6493 +1592, 68.6366, 132.6351 +1593, 65.92344, 124.4934 +1594, 70.69799, 129.6396 +1595, 68.09362, 131.2952 +1596, 69.50493, 121.3845 +1597, 67.03953, 116.8423 +1598, 69.04839, 143.4353 +1599, 70.66314, 140.0996 +1600, 67.94574, 127.1524 +1601, 68.5127, 116.4033 +1602, 68.81282, 145.5938 +1603, 67.15097, 136.0613 +1604, 68.34367, 126.2249 +1605, 67.38561, 130.9905 +1606, 64.88607, 131.7105 +1607, 65.5339, 125.1818 +1608, 69.3919, 147.0456 +1609, 66.46889, 109.3503 +1610, 63.25683, 120.7578 +1611, 67.61546, 112.4772 +1612, 69.88085, 138.4517 +1613, 70.15703, 136.7186 +1614, 70.61107, 136.0144 +1615, 71.3845, 148.7104 +1616, 66.53779, 120.4476 +1617, 71.05961, 133.5431 +1618, 67.63928, 140.0484 +1619, 63.8441, 129.0091 +1620, 66.79275, 121.0921 +1621, 68.61061, 125.6694 +1622, 70.40975, 117.6691 +1623, 65.20379, 133.959 +1624, 69.08499, 121.968 +1625, 68.29678, 135.3754 +1626, 65.83832, 111.6269 +1627, 67.18313, 117.3099 +1628, 67.87544, 131.75 +1629, 67.51672, 130.3517 +1630, 67.98827, 124.7463 +1631, 70.33848, 127.5476 +1632, 67.29728, 118.5713 +1633, 65.95685, 118.7344 +1634, 65.2832, 117.239 +1635, 71.86035, 127.4872 +1636, 67.32069, 128.9596 +1637, 68.52503, 147.7036 +1638, 69.74627, 132.158 +1639, 65.75926, 129.6624 +1640, 67.26104, 142.583 +1641, 67.59186, 123.1966 +1642, 65.54701, 114.619 +1643, 70.57745, 134.1679 +1644, 64.93595, 129.3978 +1645, 69.85715, 133.0797 +1646, 70.81884, 130.0722 +1647, 68.30112, 139.2852 +1648, 67.54828, 131.5521 +1649, 71.89737, 135.3276 +1650, 68.81871, 130.5668 +1651, 68.57948, 144.8947 +1652, 66.01716, 121.8662 +1653, 67.25756, 110.649 +1654, 70.5545, 150.0971 +1655, 66.29452, 123.8581 +1656, 68.57082, 128.4226 +1657, 68.60497, 125.197 +1658, 67.99508, 129.7427 +1659, 66.12931, 125.7215 +1660, 66.41232, 132.001 +1661, 68.42482, 140.054 +1662, 66.80813, 114.1178 +1663, 67.72371, 116.1322 +1664, 70.99035, 117.7071 +1665, 67.56098, 131.2855 +1666, 69.12684, 113.6105 +1667, 67.97635, 144.7629 +1668, 66.30036, 141.6047 +1669, 69.30957, 140.0213 +1670, 65.63213, 108.4237 +1671, 66.22333, 117.2512 +1672, 66.74595, 126.77 +1673, 69.66252, 135.074 +1674, 68.21548, 132.0189 +1675, 69.28403, 109.2101 +1676, 69.64359, 127.8589 +1677, 71.48035, 122.0737 +1678, 69.37451, 137.6851 +1679, 65.19039, 127.5918 +1680, 64.02516, 111.5819 +1681, 66.58522, 121.3966 +1682, 65.81355, 138.8427 +1683, 66.10408, 116.5048 +1684, 68.56408, 137.4424 +1685, 67.89191, 121.9768 +1686, 71.42475, 116.8105 +1687, 65.98772, 126.0482 +1688, 70.95594, 114.7284 +1689, 64.37344, 126.7487 +1690, 69.76692, 131.342 +1691, 66.46755, 119.0926 +1692, 67.76109, 137.8646 +1693, 71.17728, 129.5914 +1694, 67.31413, 128.105 +1695, 70.22181, 137.4504 +1696, 69.28985, 129.6324 +1697, 66.35778, 133.4823 +1698, 69.27648, 124.7911 +1699, 66.3778, 113.9428 +1700, 63.24012, 116.8399 +1701, 69.18211, 138.7521 +1702, 69.11432, 125.4607 +1703, 67.48024, 130.5948 +1704, 69.75327, 134.2699 +1705, 69.62313, 143.4724 +1706, 65.95463, 142.254 +1707, 68.89125, 139.8464 +1708, 67.23829, 132.4897 +1709, 67.73728, 138.5529 +1710, 68.72443, 123.1153 +1711, 65.20195, 132.6998 +1712, 66.2865, 106.6149 +1713, 68.01878, 134.9917 +1714, 66.89261, 130.92 +1715, 67.79814, 122.4887 +1716, 66.6555, 136.0645 +1717, 69.77338, 119.5334 +1718, 68.42446, 117.7405 +1719, 65.55531, 115.5734 +1720, 68.34513, 104.7006 +1721, 66.26115, 123.6592 +1722, 66.40599, 138.5289 +1723, 68.64386, 132.2257 +1724, 68.70476, 117.2914 +1725, 68.03119, 141.6933 +1726, 66.25774, 129.6313 +1727, 64.0967, 94.51219 +1728, 67.0669, 120.6412 +1729, 65.80509, 121.3762 +1730, 68.05092, 133.2667 +1731, 67.52718, 127.9032 +1732, 66.35888, 123.3962 +1733, 70.87196, 136.9675 +1734, 68.29448, 114.1357 +1735, 67.0344, 118.0845 +1736, 70.91179, 121.8608 +1737, 68.77458, 145.5199 +1738, 68.8064, 128.9862 +1739, 66.80841, 110.4729 +1740, 65.02676, 126.9126 +1741, 71.83389, 141.1132 +1742, 67.41125, 138.183 +1743, 68.8635, 132.6335 +1744, 66.39633, 127.2025 +1745, 67.90122, 146.2561 +1746, 69.04019, 141.6517 +1747, 66.26552, 126.5209 +1748, 68.4645, 121.554 +1749, 66.8815, 116.5904 +1750, 71.36376, 139.0275 +1751, 66.06344, 116.2031 +1752, 66.64834, 115.7431 +1753, 67.3297, 116.8138 +1754, 68.20575, 138.6574 +1755, 69.59793, 108.5229 +1756, 67.50819, 133.6747 +1757, 68.00385, 128.0916 +1758, 69.51431, 128.6687 +1759, 68.00582, 115.4484 +1760, 67.59357, 125.0018 +1761, 69.78942, 136.4816 +1762, 72.36491, 121.9301 +1763, 68.13393, 126.8874 +1764, 67.83776, 119.9595 +1765, 68.87619, 142.2743 +1766, 66.04124, 129.9792 +1767, 65.81569, 131.1604 +1768, 69.22762, 128.8601 +1769, 64.72395, 111.9433 +1770, 68.48588, 132.3867 +1771, 68.28041, 134.2844 +1772, 65.5087, 127.6919 +1773, 66.73361, 114.5415 +1774, 69.20114, 138.1499 +1775, 71.44618, 140.358 +1776, 70.08869, 125.9099 +1777, 69.6745, 134.4383 +1778, 71.68575, 136.6572 +1779, 71.09849, 123.5248 +1780, 67.65215, 130.345 +1781, 70.41131, 149.8413 +1782, 68.33638, 115.5647 +1783, 64.72321, 109.6661 +1784, 64.6035, 108.8823 +1785, 66.92416, 112.3914 +1786, 68.46553, 130.0139 +1787, 67.19789, 136.8066 +1788, 67.78929, 111.1892 +1789, 66.6783, 119.3179 +1790, 67.38496, 120.1224 +1791, 68.00018, 124.093 +1792, 65.27378, 117.8442 +1793, 69.14142, 142.1545 +1794, 67.46178, 122.3342 +1795, 68.87277, 115.7081 +1796, 68.02365, 136.5833 +1797, 70.33914, 120.5965 +1798, 68.05498, 121.269 +1799, 66.63059, 133.5937 +1800, 66.23781, 127.541 +1801, 70.68625, 139.1153 +1802, 67.92487, 140.4052 +1803, 67.98283, 124.3543 +1804, 67.83966, 136.9707 +1805, 70.87256, 136.9799 +1806, 68.67371, 129.9913 +1807, 65.63433, 113.6199 +1808, 66.98566, 127.6126 +1809, 69.39665, 117.966 +1810, 67.97483, 127.2407 +1811, 69.02449, 123.8412 +1812, 65.06479, 121.2687 +1813, 68.67376, 118.5378 +1814, 67.57063, 115.4182 +1815, 66.86965, 131.2651 +1816, 66.42749, 110.3212 +1817, 68.42186, 129.2128 +1818, 69.83543, 140.8802 +1819, 66.38544, 121.1068 +1820, 69.67951, 134.4281 +1821, 66.10079, 116.2489 +1822, 65.82617, 117.8009 +1823, 68.71368, 126.455 +1824, 71.38503, 137.1076 +1825, 69.73254, 152.1776 +1826, 68.37367, 128.6175 +1827, 65.05453, 113.9725 +1828, 64.38195, 105.9582 +1829, 69.22384, 134.3052 +1830, 66.67906, 132.4565 +1831, 69.15689, 134.3756 +1832, 67.53215, 146.8833 +1833, 70.71198, 131.2724 +1834, 69.06844, 132.9619 +1835, 66.36641, 140.4684 +1836, 69.74416, 144.838 +1837, 69.72221, 129.261 +1838, 67.005, 138.036 +1839, 68.39904, 125.5747 +1840, 65.72237, 129.4743 +1841, 70.41527, 129.4677 +1842, 66.08413, 105.1944 +1843, 66.34093, 125.2679 +1844, 65.25134, 128.237 +1845, 67.53562, 123.3362 +1846, 68.21037, 110.8623 +1847, 67.41542, 114.4586 +1848, 69.8279, 137.2435 +1849, 66.30495, 125.8706 +1850, 69.06175, 140.8451 +1851, 69.64603, 131.2554 +1852, 70.75572, 140.12 +1853, 67.51414, 138.8613 +1854, 67.50856, 117.374 +1855, 67.30225, 109.9978 +1856, 67.76966, 129.4122 +1857, 70.13058, 135.1643 +1858, 66.28125, 108.1378 +1859, 72.48112, 146.3046 +1860, 66.93464, 127.6499 +1861, 67.24385, 133.5096 +1862, 69.30013, 124.8396 +1863, 71.68649, 123.4209 +1864, 69.69329, 125.1731 +1865, 68.22858, 116.5013 +1866, 70.77195, 124.5635 +1867, 69.63875, 132.8562 +1868, 67.5239, 124.2136 +1869, 70.26869, 137.6254 +1870, 67.32622, 112.2365 +1871, 65.82766, 117.92 +1872, 67.28046, 107.1366 +1873, 68.47687, 127.8631 +1874, 66.16499, 119.5914 +1875, 71.12585, 129.7663 +1876, 67.51094, 126.2753 +1877, 67.98365, 120.6916 +1878, 70.76255, 147.2496 +1879, 68.13751, 123.8089 +1880, 69.7139, 124.9097 +1881, 69.28011, 129.2576 +1882, 67.72134, 133.2142 +1883, 71.35771, 134.9818 +1884, 65.01169, 115.4612 +1885, 66.57282, 114.2201 +1886, 66.2121, 126.4372 +1887, 68.42587, 121.5315 +1888, 68.25899, 137.3384 +1889, 71.66231, 130.1496 +1890, 70.73674, 149.3463 +1891, 68.81489, 131.8088 +1892, 67.8052, 124.5172 +1893, 67.28023, 124.094 +1894, 75.1528, 146.9701 +1895, 70.18385, 135.8346 +1896, 70.11018, 121.4131 +1897, 67.55479, 131.3549 +1898, 65.19685, 135.1309 +1899, 71.09811, 141.27 +1900, 63.42211, 106.4187 +1901, 69.87338, 140.1507 +1902, 67.2773, 140.0055 +1903, 66.189, 124.8413 +1904, 65.71651, 134.9238 +1905, 68.09428, 136.0939 +1906, 69.12266, 133.6055 +1907, 69.44989, 114.209 +1908, 67.09671, 144.4419 +1909, 68.50605, 127.578 +1910, 68.14059, 114.5292 +1911, 66.53479, 118.9804 +1912, 67.30796, 118.8584 +1913, 66.46388, 114.4406 +1914, 68.23072, 117.1258 +1915, 70.06314, 139.3579 +1916, 69.26881, 141.7621 +1917, 70.1554, 117.3159 +1918, 66.0776, 136.9107 +1919, 68.95747, 130.915 +1920, 66.76727, 124.4251 +1921, 69.8097, 141.0605 +1922, 67.93231, 125.3143 +1923, 69.44794, 151.3939 +1924, 71.14183, 118.1643 +1925, 66.84818, 114.446 +1926, 67.75431, 118.5776 +1927, 70.83193, 129.1185 +1928, 69.21843, 126.5898 +1929, 68.20571, 133.0472 +1930, 67.32344, 133.0028 +1931, 67.46411, 130.5289 +1932, 67.70673, 110.4494 +1933, 68.5877, 131.6199 +1934, 70.18028, 142.8787 +1935, 69.85138, 137.0263 +1936, 68.82396, 141.9518 +1937, 68.58454, 123.7734 +1938, 66.17491, 121.7871 +1939, 68.29599, 112.7853 +1940, 66.01446, 121.0144 +1941, 70.42725, 124.4965 +1942, 65.95003, 125.2296 +1943, 67.28507, 121.1903 +1944, 70.23598, 140.1737 +1945, 66.37594, 136.5133 +1946, 65.72229, 124.2645 +1947, 72.69022, 150.1384 +1948, 65.52858, 107.7887 +1949, 68.71508, 128.8673 +1950, 69.34245, 133.2224 +1951, 67.38242, 125.7706 +1952, 68.05083, 130.8925 +1953, 69.86498, 151.5925 +1954, 64.51717, 114.9571 +1955, 69.20595, 139.6118 +1956, 67.98607, 127.7814 +1957, 70.14776, 139.3701 +1958, 70.4986, 130.907 +1959, 66.86758, 134.945 +1960, 68.64908, 104.7127 +1961, 67.91149, 113.4475 +1962, 69.24385, 116.3492 +1963, 64.48072, 109.5586 +1964, 71.64447, 126.9269 +1965, 70.04642, 146.8967 +1966, 68.12343, 126.8031 +1967, 65.23383, 122.345 +1968, 68.27239, 127.8701 +1969, 66.17894, 124.9103 +1970, 65.83059, 123.0154 +1971, 65.62889, 107.4306 +1972, 70.92752, 111.6473 +1973, 69.29069, 130.6183 +1974, 69.91684, 132.766 +1975, 72.73301, 125.9357 +1976, 68.44904, 113.1008 +1977, 66.49335, 123.1309 +1978, 72.21533, 122.7007 +1979, 69.53524, 139.1563 +1980, 64.79882, 122.5688 +1981, 67.38254, 126.915 +1982, 67.65345, 131.7026 +1983, 70.01257, 144.6798 +1984, 66.05945, 133.332 +1985, 65.21051, 109.8084 +1986, 68.39529, 132.9511 +1987, 63.99095, 123.6623 +1988, 70.31847, 120.0304 +1989, 70.15159, 123.1364 +1990, 68.01671, 122.7495 +1991, 68.06098, 125.8274 +1992, 66.98618, 117.2347 +1993, 68.8061, 142.7741 +1994, 70.30067, 114.5538 +1995, 65.68106, 111.1723 +1996, 69.27665, 141.7056 +1997, 71.68898, 126.5743 +1998, 67.17092, 148.2722 +1999, 69.24215, 132.6836 +2000, 68.73563, 126.8221 +2001, 69.00812, 125.4763 +2002, 68.69462, 130.1342 +2003, 68.53874, 123.2715 +2004, 67.68634, 129.9806 +2005, 69.60608, 138.6734 +2006, 68.91393, 130.7056 +2007, 66.17148, 113.3707 +2008, 67.46209, 139.6833 +2009, 72.83513, 148.8002 +2010, 64.01976, 90.91793 +2011, 68.02868, 123.7533 +2012, 68.51623, 132.4995 +2013, 70.88524, 131.3128 +2014, 65.29862, 116.5172 +2015, 65.7635, 109.1144 +2016, 65.46143, 129.339 +2017, 65.99098, 114.6394 +2018, 65.57951, 136.1447 +2019, 69.70616, 144.5925 +2020, 66.1974, 107.9777 +2021, 68.23074, 122.0759 +2022, 65.97964, 123.3232 +2023, 71.26857, 133.6208 +2024, 72.01497, 159.2724 +2025, 68.93137, 148.7762 +2026, 67.36601, 120.2868 +2027, 70.12256, 110.3036 +2028, 68.84918, 137.6134 +2029, 67.62215, 132.4802 +2030, 67.13659, 136.4192 +2031, 70.39143, 137.2703 +2032, 68.68117, 134.8569 +2033, 66.92629, 118.8555 +2034, 69.87266, 144.0381 +2035, 67.94061, 128.518 +2036, 68.495, 125.988 +2037, 69.45516, 121.0884 +2038, 67.72991, 125.3854 +2039, 69.85473, 141.3991 +2040, 66.63111, 141.1397 +2041, 66.36326, 116.8585 +2042, 68.2269, 131.1664 +2043, 68.40577, 134.5811 +2044, 68.44489, 133.1242 +2045, 70.94089, 137.7195 +2046, 69.65687, 130.2491 +2047, 65.06613, 109.5825 +2048, 71.81628, 142.8719 +2049, 65.92674, 101.6217 +2050, 66.52018, 112.3553 +2051, 70.52744, 131.0845 +2052, 66.25032, 131.0484 +2053, 64.72936, 111.5548 +2054, 63.79906, 110.8498 +2055, 65.38373, 127.4708 +2056, 65.57359, 107.7067 +2057, 66.57608, 115.1232 +2058, 67.28745, 112.1197 +2059, 66.14358, 128.0777 +2060, 66.11741, 119.4651 +2061, 67.68233, 124.5983 +2062, 68.74723, 126.0285 +2063, 66.5915, 111.3977 +2064, 65.01782, 127.722 +2065, 69.28345, 124.8207 +2066, 67.19343, 122.9788 +2067, 69.81336, 117.7117 +2068, 66.55388, 120.7289 +2069, 66.14617, 121.3302 +2070, 69.93036, 146.6089 +2071, 66.70056, 126.013 +2072, 67.68095, 128.1474 +2073, 67.87796, 129.5415 +2074, 67.65549, 121.5145 +2075, 71.1713, 157.9626 +2076, 69.01806, 127.8941 +2077, 70.58265, 127.1594 +2078, 70.89693, 140.8109 +2079, 68.51895, 140.1451 +2080, 66.61835, 132.7723 +2081, 66.07169, 116.0089 +2082, 68.1535, 121.2886 +2083, 72.89832, 147.5384 +2084, 69.90164, 138.8642 +2085, 66.50525, 120.8563 +2086, 69.27168, 125.8179 +2087, 70.53643, 135.3753 +2088, 65.1243, 107.6247 +2089, 70.34418, 122.9851 +2090, 69.13083, 131.7164 +2091, 65.21067, 110.3376 +2092, 67.08781, 100.2532 +2093, 64.65639, 106.579 +2094, 66.28071, 121.223 +2095, 71.30341, 130.5588 +2096, 66.91234, 132.6182 +2097, 70.84318, 132.613 +2098, 66.65796, 117.8331 +2099, 64.54303, 94.29987 +2100, 66.43942, 125.1826 +2101, 66.60747, 125.3684 +2102, 66.38807, 117.4577 +2103, 66.85611, 130.8168 +2104, 68.50863, 128.3144 +2105, 63.45049, 118.4083 +2106, 67.54653, 129.4669 +2107, 65.41398, 116.7348 +2108, 66.91885, 146.8505 +2109, 67.59652, 120.2168 +2110, 67.05552, 136.2774 +2111, 68.00153, 130.1697 +2112, 70.33681, 134.8282 +2113, 69.10376, 126.2799 +2114, 68.12704, 142.6738 +2115, 67.5512, 121.2891 +2116, 68.78357, 111.1965 +2117, 66.62497, 130.424 +2118, 67.88387, 138.8309 +2119, 67.75152, 125.105 +2120, 68.3286, 141.6323 +2121, 71.05207, 149.779 +2122, 68.11943, 118.6268 +2123, 66.44223, 119.4357 +2124, 71.4563, 134.9113 +2125, 68.60548, 133.1629 +2126, 70.82734, 147.2884 +2127, 68.89076, 117.6717 +2128, 67.15411, 122.843 +2129, 68.76271, 125.7926 +2130, 70.53185, 143.2531 +2131, 66.47953, 127.2118 +2132, 67.94262, 113.7238 +2133, 68.79538, 130.932 +2134, 69.95518, 129.5075 +2135, 69.99489, 157.6149 +2136, 66.55505, 125.4636 +2137, 65.14815, 105.3601 +2138, 70.40094, 130.4476 +2139, 68.32002, 152.0527 +2140, 65.60842, 143.9545 +2141, 70.63864, 136.1993 +2142, 65.08404, 117.4157 +2143, 64.31842, 114.5616 +2144, 66.0525, 115.1065 +2145, 67.35994, 121.8544 +2146, 70.1376, 150.2085 +2147, 67.49796, 122.1628 +2148, 67.1125, 115.5902 +2149, 67.27925, 133.3105 +2150, 66.55492, 141.4402 +2151, 68.1384, 130.7908 +2152, 68.54096, 143.1515 +2153, 68.52593, 138.0426 +2154, 70.77318, 120.9532 +2155, 66.72984, 104.5502 +2156, 66.30573, 120.3066 +2157, 66.1654, 116.7474 +2158, 65.52686, 127.6185 +2159, 71.0176, 128.7638 +2160, 64.0731, 132.1263 +2161, 67.07894, 136.2565 +2162, 66.92118, 114.2461 +2163, 63.92073, 117.7804 +2164, 66.76895, 121.7656 +2165, 67.31046, 117.4512 +2166, 66.94519, 137.7336 +2167, 69.97793, 133.2135 +2168, 66.4156, 114.16 +2169, 69.46121, 136.8798 +2170, 66.47267, 125.4235 +2171, 67.69989, 121.4915 +2172, 68.6046, 123.3492 +2173, 66.82256, 107.8004 +2174, 66.31555, 117.1775 +2175, 69.11039, 126.3083 +2176, 65.94386, 115.3139 +2177, 69.86148, 143.7522 +2178, 64.55479, 113.2482 +2179, 65.56126, 131.7643 +2180, 65.07865, 125.8387 +2181, 66.30496, 115.8846 +2182, 68.63331, 139.0539 +2183, 67.39243, 121.7331 +2184, 66.73104, 141.1317 +2185, 65.57961, 127.9611 +2186, 67.97668, 132.1352 +2187, 62.60611, 129.76 +2188, 66.26361, 129.4162 +2189, 65.65796, 118.7804 +2190, 66.31902, 105.7105 +2191, 65.15141, 124.8365 +2192, 67.06755, 141.8106 +2193, 68.07294, 123.0209 +2194, 68.73375, 118.3051 +2195, 66.50974, 123.1286 +2196, 71.35483, 125.0842 +2197, 67.36943, 118.0443 +2198, 66.53342, 134.41 +2199, 67.44518, 132.5899 +2200, 69.37871, 123.6421 +2201, 68.47617, 136.737 +2202, 66.81962, 130.4451 +2203, 68.62691, 121.9836 +2204, 70.55478, 124.8816 +2205, 65.26709, 110.6805 +2206, 65.35329, 108.9072 +2207, 65.63866, 129.7145 +2208, 69.57228, 140.2426 +2209, 66.41871, 137.8126 +2210, 68.25694, 140.6602 +2211, 70.74604, 136.5621 +2212, 68.35787, 121.0365 +2213, 69.64013, 141.548 +2214, 65.35452, 137.184 +2215, 71.92675, 156.5442 +2216, 70.13403, 137.22 +2217, 65.16717, 121.5264 +2218, 69.31063, 122.0461 +2219, 66.33317, 131.3132 +2220, 68.65304, 127.5565 +2221, 70.27541, 135.3191 +2222, 67.57713, 128.8936 +2223, 69.1971, 134.756 +2224, 69.6239, 129.9452 +2225, 65.86809, 127.9121 +2226, 69.92456, 134.6123 +2227, 68.42315, 138.5594 +2228, 67.61231, 145.1953 +2229, 68.12858, 113.7951 +2230, 64.76601, 118.6754 +2231, 65.33382, 129.7622 +2232, 67.64472, 133.5081 +2233, 69.06267, 139.8787 +2234, 67.17574, 117.2661 +2235, 65.69758, 116.9811 +2236, 68.57486, 141.1557 +2237, 66.34328, 138.224 +2238, 62.78196, 119.847 +2239, 65.28308, 112.5769 +2240, 69.9312, 139.7362 +2241, 65.2271, 130.6158 +2242, 71.57674, 142.2788 +2243, 69.1121, 134.2085 +2244, 68.83916, 123.6683 +2245, 66.39741, 119.1475 +2246, 66.69861, 133.9891 +2247, 64.95406, 115.6216 +2248, 69.50341, 135.2493 +2249, 69.43668, 115.9697 +2250, 67.07002, 121.3118 +2251, 70.49846, 134.3579 +2252, 69.18776, 143.0344 +2253, 67.48622, 119.856 +2254, 67.40826, 124.8424 +2255, 69.43651, 127.9505 +2256, 64.15318, 112.225 +2257, 69.14007, 137.3179 +2258, 68.8929, 120.1185 +2259, 64.95274, 93.44115 +2260, 66.41945, 137.0321 +2261, 67.42646, 124.5909 +2262, 65.63755, 126.3297 +2263, 70.16858, 128.3273 +2264, 66.23711, 130.688 +2265, 66.49138, 138.4146 +2266, 65.0471, 116.7381 +2267, 67.08449, 118.1314 +2268, 64.3389, 128.2028 +2269, 64.20833, 113.1561 +2270, 66.89449, 113.1405 +2271, 65.79218, 126.8992 +2272, 68.843, 131.3916 +2273, 71.09755, 143.3004 +2274, 63.8882, 122.9986 +2275, 68.35671, 136.7665 +2276, 69.47682, 140.3565 +2277, 69.0265, 138.7555 +2278, 70.29803, 135.4454 +2279, 70.84459, 135.3925 +2280, 71.86799, 144.6497 +2281, 69.57461, 139.8465 +2282, 70.88841, 136.5899 +2283, 67.94317, 123.7762 +2284, 67.70347, 127.8934 +2285, 68.59478, 148.9399 +2286, 66.91402, 128.9211 +2287, 68.33449, 125.5417 +2288, 64.65946, 140.4392 +2289, 66.05221, 115.642 +2290, 70.24304, 130.7133 +2291, 67.37048, 119.0077 +2292, 69.95831, 128.0902 +2293, 70.64717, 153.0286 +2294, 70.5802, 127.6482 +2295, 68.86101, 134.8113 +2296, 68.7432, 121.5345 +2297, 67.17409, 128.304 +2298, 65.78148, 107.3133 +2299, 67.52494, 136.2616 +2300, 67.08075, 149.1684 +2301, 67.69345, 129.6252 +2302, 64.64051, 105.8442 +2303, 69.36402, 113.9182 +2304, 69.2178, 142.8796 +2305, 67.36034, 119.1631 +2306, 65.63764, 117.8529 +2307, 68.76324, 126.8712 +2308, 68.17144, 124.9338 +2309, 65.83305, 103.8489 +2310, 69.30622, 130.2827 +2311, 70.8049, 123.8101 +2312, 66.59071, 137.5423 +2313, 64.67352, 104.9377 +2314, 71.93986, 129.2747 +2315, 67.64634, 120.458 +2316, 68.73411, 126.8398 +2317, 66.95634, 127.1688 +2318, 72.56549, 130.0389 +2319, 67.36934, 136.9061 +2320, 70.02946, 135.9857 +2321, 66.54034, 110.9114 +2322, 67.74769, 113.6583 +2323, 67.57706, 144.701 +2324, 66.52633, 133.8333 +2325, 69.15551, 152.127 +2326, 69.19157, 122.7961 +2327, 66.60061, 118.2649 +2328, 67.07004, 106.2097 +2329, 69.57028, 148.5705 +2330, 69.23016, 101.4527 +2331, 69.26795, 137.5001 +2332, 67.56717, 123.1061 +2333, 69.10176, 142.433 +2334, 68.54151, 127.3761 +2335, 70.86149, 151.2788 +2336, 67.9873, 124.5609 +2337, 71.04092, 127.1598 +2338, 66.70805, 140.2543 +2339, 65.77676, 113.7058 +2340, 66.79414, 116.248 +2341, 65.93191, 109.5517 +2342, 67.72422, 131.8711 +2343, 66.72423, 112.366 +2344, 66.68607, 115.4197 +2345, 67.25768, 119.9769 +2346, 70.52978, 128.2009 +2347, 69.74125, 128.6789 +2348, 68.75608, 115.2882 +2349, 67.61299, 136.677 +2350, 72.13419, 137.7854 +2351, 67.91004, 126.6205 +2352, 66.18756, 125.3221 +2353, 71.71529, 144.446 +2354, 70.6841, 137.8075 +2355, 71.87845, 143.0609 +2356, 67.75918, 131.826 +2357, 67.09216, 122.1749 +2358, 66.79895, 105.8924 +2359, 63.56132, 118.8125 +2360, 66.49532, 139.3133 +2361, 68.50215, 124.2763 +2362, 66.83975, 116.7159 +2363, 70.64111, 134.415 +2364, 66.0167, 117.703 +2365, 67.3482, 126.8963 +2366, 67.26092, 120.9883 +2367, 70.82199, 140.3611 +2368, 68.33332, 102.5002 +2369, 69.37897, 132.5554 +2370, 64.7609, 119.6373 +2371, 68.699, 125.9149 +2372, 69.49404, 125.5505 +2373, 68.0849, 122.5232 +2374, 66.37539, 134.8766 +2375, 66.75613, 121.5063 +2376, 69.64206, 123.3271 +2377, 69.77774, 133.0832 +2378, 69.49214, 118.9607 +2379, 65.84828, 101.1193 +2380, 70.71369, 143.1946 +2381, 68.48099, 126.7384 +2382, 69.37374, 141.1484 +2383, 70.52541, 135.1763 +2384, 68.70978, 128.8899 +2385, 67.62641, 109.3522 +2386, 68.33709, 137.5541 +2387, 68.23178, 139.1303 +2388, 67.91161, 132.0641 +2389, 70.32186, 136.4673 +2390, 66.39807, 128.5349 +2391, 66.51667, 134.4822 +2392, 69.61525, 122.5729 +2393, 67.63565, 140.0854 +2394, 71.06313, 139.9112 +2395, 70.62246, 127.4324 +2396, 73.99549, 142.9016 +2397, 67.4663, 125.8276 +2398, 65.91279, 101.2434 +2399, 65.60691, 115.9997 +2400, 69.50033, 126.7393 +2401, 69.43735, 133.5447 +2402, 69.00905, 116.1499 +2403, 68.58614, 124.1333 +2404, 66.96198, 118.7229 +2405, 64.56606, 135.4686 +2406, 69.48658, 132.5799 +2407, 65.65789, 145.9751 +2408, 66.80094, 112.1247 +2409, 68.93784, 135.9755 +2410, 68.90478, 120.921 +2411, 68.50005, 132.7228 +2412, 68.02851, 135.0685 +2413, 69.2145, 134.8578 +2414, 68.48721, 141.7791 +2415, 68.80928, 151.4206 +2416, 67.04824, 134.1504 +2417, 68.89055, 139.3242 +2418, 68.75779, 132.5058 +2419, 72.33195, 143.5202 +2420, 66.51286, 121.8849 +2421, 66.7188, 122.9302 +2422, 67.20628, 118.5206 +2423, 70.19428, 131.9154 +2424, 65.51378, 122.5787 +2425, 68.83979, 113.5812 +2426, 66.95528, 129.9893 +2427, 68.03878, 123.9609 +2428, 71.01151, 119.9164 +2429, 69.14341, 124.9403 +2430, 68.86125, 131.6645 +2431, 64.6203, 109.2955 +2432, 68.44749, 110.9724 +2433, 68.82404, 121.5044 +2434, 66.41585, 127.7426 +2435, 68.86164, 147.5692 +2436, 65.7798, 148.7053 +2437, 63.82215, 109.0177 +2438, 67.97504, 119.6017 +2439, 68.39135, 123.7223 +2440, 66.54816, 124.8416 +2441, 71.1807, 144.0008 +2442, 66.03415, 136.0093 +2443, 66.19208, 127.1191 +2444, 65.8689, 121.6531 +2445, 68.65011, 128.9604 +2446, 68.79753, 135.4419 +2447, 66.39828, 123.0735 +2448, 68.08765, 120.0428 +2449, 68.20122, 120.2027 +2450, 64.65154, 124.8094 +2451, 69.30569, 133.7108 +2452, 67.89566, 118.2086 +2453, 66.23676, 131.8546 +2454, 66.84304, 113.6315 +2455, 68.77237, 131.1206 +2456, 68.78389, 141.022 +2457, 70.30029, 128.1661 +2458, 67.68475, 124.7755 +2459, 69.56671, 131.8861 +2460, 69.36532, 124.6139 +2461, 66.46909, 112.5943 +2462, 71.37399, 146.4358 +2463, 68.12643, 126.6456 +2464, 69.49226, 136.9902 +2465, 65.07859, 118.1795 +2466, 66.27357, 144.6287 +2467, 70.26356, 154.9408 +2468, 67.37111, 116.9522 +2469, 68.38613, 140.6401 +2470, 68.68559, 116.6275 +2471, 66.67024, 136.6266 +2472, 71.15168, 131.1853 +2473, 63.86399, 113.9441 +2474, 69.25001, 134.6576 +2475, 67.20448, 107.6304 +2476, 66.94316, 106.9521 +2477, 67.99592, 146.6396 +2478, 67.12143, 114.9585 +2479, 69.87331, 131.0168 +2480, 67.35332, 127.6156 +2481, 71.53386, 145.1178 +2482, 75.11519, 153.9562 +2483, 67.61043, 133.6125 +2484, 64.23075, 127.6976 +2485, 65.51542, 126.4846 +2486, 63.1937, 90.6784 +2487, 68.69521, 109.923 +2488, 66.22516, 101.8528 +2489, 69.44849, 114.3461 +2490, 70.73043, 125.1501 +2491, 70.1737, 157.2751 +2492, 64.7817, 111.8687 +2493, 63.91382, 102.5247 +2494, 68.02246, 129.9915 +2495, 70.48458, 156.3703 +2496, 68.31433, 122.7189 +2497, 68.63014, 125.6964 +2498, 68.12174, 126.2062 +2499, 67.40773, 155.2615 +2500, 68.97304, 142.8808 +2501, 65.72097, 121.262 +2502, 68.32077, 124.3155 +2503, 67.56613, 111.6843 +2504, 69.50262, 124.186 +2505, 67.82427, 126.4867 +2506, 70.85958, 142.6651 +2507, 64.04489, 108.8473 +2508, 66.43905, 116.66 +2509, 68.79621, 143.6181 +2510, 70.05244, 123.0933 +2511, 66.04605, 115.0598 +2512, 69.05127, 132.1098 +2513, 65.61974, 120.7598 +2514, 67.60382, 119.7671 +2515, 67.89065, 122.1496 +2516, 70.01739, 123.9711 +2517, 67.80728, 121.4194 +2518, 67.14185, 123.66 +2519, 65.39888, 98.05813 +2520, 68.70988, 133.8099 +2521, 69.04936, 141.6987 +2522, 67.91969, 117.5158 +2523, 72.30217, 132.1645 +2524, 63.7019, 124.5106 +2525, 70.475, 105.7802 +2526, 67.64613, 133.4242 +2527, 67.75898, 125.3875 +2528, 69.1102, 132.6382 +2529, 65.59124, 121.0751 +2530, 67.63581, 121.5355 +2531, 70.74732, 142.0038 +2532, 70.99416, 135.1886 +2533, 67.66798, 118.3373 +2534, 67.19997, 122.9425 +2535, 67.4785, 116.4973 +2536, 67.66945, 133.004 +2537, 70.62281, 146.4085 +2538, 68.85256, 137.2776 +2539, 65.32564, 122.0439 +2540, 68.76499, 140.8147 +2541, 70.56586, 136.7946 +2542, 69.11378, 127.4421 +2543, 69.47685, 130.272 +2544, 70.13374, 131.169 +2545, 66.07211, 129.6342 +2546, 68.40149, 125.6933 +2547, 65.13161, 104.973 +2548, 64.07239, 120.2984 +2549, 63.84484, 102.4259 +2550, 65.55111, 123.8357 +2551, 66.41112, 117.7 +2552, 65.05758, 121.8919 +2553, 69.2384, 128.4571 +2554, 68.75803, 113.1578 +2555, 68.17548, 125.2742 +2556, 70.1552, 139.8009 +2557, 67.70652, 121.3818 +2558, 66.95169, 114.5435 +2559, 70.92538, 133.8388 +2560, 66.06089, 135.6656 +2561, 66.10974, 127.3786 +2562, 70.57236, 140.6434 +2563, 66.67735, 113.9708 +2564, 65.99458, 120.7042 +2565, 63.44297, 116.0752 +2566, 66.32955, 131.0291 +2567, 66.53488, 134.6458 +2568, 66.80528, 111.616 +2569, 67.9896, 110.0452 +2570, 64.99295, 106.053 +2571, 66.56539, 124.0282 +2572, 66.804, 113.4492 +2573, 67.96612, 132.3117 +2574, 64.71711, 118.356 +2575, 65.82856, 106.1109 +2576, 69.08496, 136.7244 +2577, 68.28753, 125.6799 +2578, 71.11334, 126.4908 +2579, 69.34872, 148.1527 +2580, 67.62203, 117.9474 +2581, 66.06295, 124.5018 +2582, 70.00342, 127.0128 +2583, 66.52881, 127.605 +2584, 68.60366, 129.5427 +2585, 69.53265, 142.0317 +2586, 69.5404, 134.8729 +2587, 68.42714, 124.9955 +2588, 70.12002, 137.7196 +2589, 68.89234, 116.8002 +2590, 67.64467, 123.6212 +2591, 68.97063, 129.4071 +2592, 71.51466, 151.9696 +2593, 70.71134, 142.4361 +2594, 66.90583, 114.3278 +2595, 69.57597, 106.1963 +2596, 66.48164, 111.3787 +2597, 66.89809, 118.3329 +2598, 69.13909, 138.206 +2599, 68.61774, 132.7075 +2600, 66.16611, 111.9004 +2601, 66.64128, 114.0856 +2602, 69.54521, 123.4319 +2603, 62.86795, 98.05815 +2604, 67.85282, 125.754 +2605, 68.54477, 133.7416 +2606, 68.66811, 143.6143 +2607, 70.12714, 123.7248 +2608, 66.78985, 127.694 +2609, 67.27782, 126.7293 +2610, 66.9553, 121.6118 +2611, 69.44337, 123.5342 +2612, 71.51895, 143.988 +2613, 69.66995, 137.9075 +2614, 68.47294, 109.4371 +2615, 66.19926, 110.991 +2616, 68.78565, 144.0145 +2617, 67.86643, 121.9737 +2618, 67.76132, 128.252 +2619, 68.54873, 117.4352 +2620, 68.46365, 130.4536 +2621, 67.00444, 93.78282 +2622, 68.04189, 121.4741 +2623, 70.80235, 140.4798 +2624, 67.7232, 120.5494 +2625, 68.05748, 126.1797 +2626, 69.86881, 128.3204 +2627, 67.67538, 105.9584 +2628, 68.32806, 126.9252 +2629, 69.88401, 142.7832 +2630, 68.80968, 111.1686 +2631, 68.36811, 114.3121 +2632, 68.8827, 143.8443 +2633, 64.85888, 121.0848 +2634, 67.02277, 136.9794 +2635, 65.65821, 123.2681 +2636, 70.01384, 130.2018 +2637, 68.95576, 129.1215 +2638, 69.72231, 135.8375 +2639, 68.26031, 138.5268 +2640, 67.79651, 146.5558 +2641, 66.57574, 114.2481 +2642, 70.38311, 146.8498 +2643, 66.49668, 122.807 +2644, 68.21731, 127.527 +2645, 68.08084, 130.6424 +2646, 66.89732, 125.6947 +2647, 71.03529, 135.7172 +2648, 67.69483, 110.6572 +2649, 66.71312, 122.9811 +2650, 66.19389, 115.5235 +2651, 70.84883, 125.1626 +2652, 60.61265, 88.04646 +2653, 69.33158, 109.2915 +2654, 68.82694, 127.2504 +2655, 68.76714, 110.0752 +2656, 68.3665, 121.2376 +2657, 68.8963, 113.0423 +2658, 71.52552, 144.707 +2659, 66.3396, 111.3345 +2660, 69.24295, 139.3186 +2661, 65.44706, 129.4057 +2662, 64.98078, 121.7515 +2663, 64.73308, 112.2606 +2664, 65.95421, 123.4114 +2665, 69.23656, 113.0173 +2666, 66.6319, 113.3885 +2667, 65.56464, 111.7275 +2668, 67.89517, 127.8383 +2669, 66.72053, 134.4433 +2670, 67.33628, 133.6352 +2671, 68.00682, 128.9038 +2672, 69.59907, 140.7606 +2673, 65.7514, 121.8273 +2674, 66.54868, 133.0094 +2675, 68.67978, 122.6398 +2676, 67.29012, 149.083 +2677, 67.91637, 136.5971 +2678, 65.73796, 111.1435 +2679, 67.89939, 107.5045 +2680, 72.78908, 137.0203 +2681, 65.98489, 129.277 +2682, 69.67441, 121.7105 +2683, 66.75669, 116.2148 +2684, 67.43375, 117.4727 +2685, 67.67624, 123.6071 +2686, 71.25079, 133.5001 +2687, 69.21284, 122.3603 +2688, 70.47954, 134.4949 +2689, 65.27987, 134.6225 +2690, 71.09122, 139.2202 +2691, 69.56615, 124.2333 +2692, 66.89046, 128.8185 +2693, 67.70276, 138.9186 +2694, 66.77085, 121.5008 +2695, 67.85276, 148.7195 +2696, 70.78378, 124.5162 +2697, 67.09928, 121.3383 +2698, 70.44992, 133.1712 +2699, 69.80734, 137.2218 +2700, 69.2187, 156.353 +2701, 69.75148, 147.7342 +2702, 69.25709, 142.5795 +2703, 69.00485, 122.6004 +2704, 66.51077, 127.8756 +2705, 71.06999, 121.0861 +2706, 73.10762, 151.6868 +2707, 71.20673, 137.8023 +2708, 64.27555, 102.5237 +2709, 70.05278, 122.6111 +2710, 66.79032, 105.706 +2711, 68.34193, 113.765 +2712, 68.51775, 134.1383 +2713, 68.93108, 138.9163 +2714, 66.41503, 110.2628 +2715, 66.67827, 108.1567 +2716, 70.52101, 146.2975 +2717, 68.30664, 134.6639 +2718, 67.0116, 136.9904 +2719, 69.88845, 125.9301 +2720, 69.26417, 131.5566 +2721, 67.90954, 120.4869 +2722, 62.73809, 105.2201 +2723, 67.25447, 117.0512 +2724, 65.59876, 117.1139 +2725, 69.77845, 122.691 +2726, 70.90472, 150.021 +2727, 67.19538, 111.1027 +2728, 67.90593, 122.2626 +2729, 69.80063, 145.7116 +2730, 66.6932, 139.5749 +2731, 67.39204, 119.839 +2732, 67.05894, 120.139 +2733, 69.77321, 143.6484 +2734, 68.61434, 142.6088 +2735, 68.04448, 114.4534 +2736, 69.71027, 160.8859 +2737, 69.63078, 132.8733 +2738, 71.04817, 138.0744 +2739, 67.8894, 128.7946 +2740, 69.08591, 139.7656 +2741, 70.50786, 127.2788 +2742, 66.75964, 140.3527 +2743, 66.45788, 118.3607 +2744, 64.38452, 109.4539 +2745, 67.70213, 135.3701 +2746, 72.16119, 141.8671 +2747, 66.73368, 134.3878 +2748, 64.59658, 113.6028 +2749, 69.18583, 136.7389 +2750, 67.70525, 142.2085 +2751, 70.46124, 132.8252 +2752, 66.84239, 135.3456 +2753, 68.09464, 126.5742 +2754, 69.27278, 141.667 +2755, 66.06118, 114.3427 +2756, 68.85839, 142.794 +2757, 68.24827, 109.1823 +2758, 69.68789, 123.3539 +2759, 70.34077, 139.9099 +2760, 68.47674, 118.7857 +2761, 66.78425, 122.2756 +2762, 67.06985, 124.811 +2763, 68.38893, 112.4658 +2764, 67.18538, 111.7251 +2765, 66.8759, 109.1189 +2766, 72.46405, 138.8395 +2767, 68.05495, 125.6718 +2768, 68.9238, 129.8238 +2769, 66.55309, 117.9982 +2770, 68.00334, 133.4084 +2771, 62.53614, 120.647 +2772, 70.71058, 140.2181 +2773, 68.53707, 125.2862 +2774, 70.0098, 151.713 +2775, 68.65745, 120.2825 +2776, 68.89097, 119.1438 +2777, 67.25272, 133.3836 +2778, 67.39484, 133.6104 +2779, 63.37237, 128.7288 +2780, 67.9351, 120.8477 +2781, 68.38418, 131.7234 +2782, 68.37863, 134.8459 +2783, 65.57367, 137.9377 +2784, 65.23577, 128.5973 +2785, 71.3169, 139.8829 +2786, 70.16627, 129.0204 +2787, 67.42392, 122.5717 +2788, 70.49904, 114.3634 +2789, 68.30668, 135.853 +2790, 67.14412, 135.207 +2791, 64.68621, 94.21971 +2792, 66.82203, 140.4193 +2793, 66.17213, 123.9367 +2794, 67.40223, 129.5135 +2795, 69.65239, 148.1859 +2796, 64.6447, 120.4178 +2797, 63.86895, 97.02574 +2798, 67.7235, 114.9802 +2799, 66.78698, 104.0527 +2800, 68.37223, 140.6462 +2801, 68.04613, 118.4149 +2802, 70.70988, 146.6187 +2803, 68.42309, 133.7406 +2804, 69.39765, 118.5079 +2805, 71.73856, 150.9213 +2806, 70.69601, 121.8109 +2807, 69.79586, 146.1372 +2808, 69.20814, 128.8862 +2809, 66.49242, 128.4737 +2810, 67.16108, 139.2681 +2811, 68.76219, 126.9364 +2812, 66.64609, 134.9489 +2813, 69.91623, 141.9177 +2814, 70.71477, 137.8023 +2815, 68.86691, 117.7445 +2816, 65.56879, 119.5334 +2817, 70.7695, 147.1214 +2818, 68.31719, 134.2732 +2819, 63.7678, 97.04078 +2820, 66.49473, 122.836 +2821, 69.21965, 129.9591 +2822, 71.49924, 149.1274 +2823, 67.75486, 128.5848 +2824, 66.19603, 117.3529 +2825, 65.29404, 112.1173 +2826, 68.37324, 129.5659 +2827, 69.09809, 121.057 +2828, 68.5956, 110.0357 +2829, 67.78989, 120.7787 +2830, 67.02507, 122.308 +2831, 66.31844, 126.8147 +2832, 66.33367, 140.2312 +2833, 65.50586, 111.649 +2834, 68.05216, 124.0093 +2835, 69.33545, 135.4809 +2836, 66.39304, 126.1881 +2837, 69.2076, 143.3931 +2838, 70.21379, 122.1613 +2839, 69.178, 142.7784 +2840, 66.76739, 134.2148 +2841, 64.88316, 125.5308 +2842, 70.25427, 130.1801 +2843, 68.38013, 130.1171 +2844, 66.62364, 121.8803 +2845, 67.96737, 116.8868 +2846, 69.07966, 128.4637 +2847, 65.49639, 108.2566 +2848, 67.94823, 131.4797 +2849, 67.69124, 131.0789 +2850, 69.9714, 134.3432 +2851, 67.69387, 112.2898 +2852, 65.98735, 113.6996 +2853, 68.3664, 128.5446 +2854, 69.52877, 136.7997 +2855, 69.27294, 130.2612 +2856, 69.41669, 128.4186 +2857, 70.15337, 139.8741 +2858, 69.82573, 132.6543 +2859, 65.91827, 115.9192 +2860, 67.98945, 118.7202 +2861, 72.12813, 135.5268 +2862, 67.48301, 113.3464 +2863, 68.26193, 117.904 +2864, 69.41184, 130.5207 +2865, 67.82148, 123.5959 +2866, 69.69729, 141.3599 +2867, 63.45113, 104.2273 +2868, 66.9028, 122.3933 +2869, 69.05969, 134.2747 +2870, 69.02413, 120.2068 +2871, 65.1896, 127.2096 +2872, 65.30411, 119.1556 +2873, 67.8454, 100.2365 +2874, 67.09743, 121.1992 +2875, 65.5786, 108.1626 +2876, 68.31828, 129.8971 +2877, 67.77752, 125.3103 +2878, 67.83922, 130.7952 +2879, 67.09143, 127.9221 +2880, 68.6965, 135.3072 +2881, 70.66714, 141.6093 +2882, 65.74989, 134.5339 +2883, 68.51671, 135.9882 +2884, 67.59335, 125.5196 +2885, 65.84344, 123.0473 +2886, 64.9153, 118.3384 +2887, 64.58123, 119.5443 +2888, 66.90827, 136.7318 +2889, 68.0883, 129.1382 +2890, 65.46098, 117.3543 +2891, 69.62403, 133.886 +2892, 70.62668, 127.1567 +2893, 65.82364, 118.264 +2894, 65.06787, 120.8378 +2895, 66.22122, 132.7183 +2896, 69.68826, 125.88 +2897, 69.70612, 129.4925 +2898, 67.65097, 136.1796 +2899, 69.95219, 133.0623 +2900, 70.00937, 129.9978 +2901, 67.61783, 125.53 +2902, 69.31318, 139.8597 +2903, 68.22656, 132.6316 +2904, 68.55723, 118.8729 +2905, 64.22112, 122.1174 +2906, 66.05632, 127.3063 +2907, 66.90354, 113.6921 +2908, 66.84621, 121.585 +2909, 69.4938, 146.0665 +2910, 68.55353, 113.6965 +2911, 65.61282, 110.3262 +2912, 67.37674, 124.0148 +2913, 68.09175, 128.9185 +2914, 66.65804, 117.0019 +2915, 69.54961, 144.9385 +2916, 66.25728, 123.9976 +2917, 67.98509, 135.5365 +2918, 66.09544, 126.996 +2919, 70.52477, 134.6828 +2920, 67.19875, 111.0968 +2921, 68.24137, 121.9514 +2922, 70.97253, 134.2293 +2923, 66.62434, 128.3887 +2924, 65.60995, 124.7491 +2925, 67.79978, 111.9651 +2926, 67.56776, 128.4301 +2927, 65.14281, 113.4592 +2928, 65.46067, 129.2624 +2929, 68.4843, 131.5885 +2930, 68.24746, 126.4105 +2931, 68.62227, 137.2275 +2932, 67.23277, 123.8138 +2933, 70.9315, 124.931 +2934, 70.41644, 145.2017 +2935, 67.76785, 125.2728 +2936, 68.93413, 128.9511 +2937, 66.63682, 123.6178 +2938, 68.50584, 123.3779 +2939, 66.74655, 103.455 +2940, 68.34022, 121.1823 +2941, 68.64082, 104.9272 +2942, 67.7798, 119.9736 +2943, 68.01308, 132.8794 +2944, 64.20657, 119.5831 +2945, 68.16944, 128.8536 +2946, 67.55289, 125.4723 +2947, 67.94972, 120.232 +2948, 65.82888, 110.4565 +2949, 67.43166, 138.2801 +2950, 69.76313, 124.4852 +2951, 66.74117, 117.0476 +2952, 67.23078, 127.707 +2953, 66.219, 121.3801 +2954, 65.57556, 126.3779 +2955, 66.46532, 105.6146 +2956, 71.70666, 150.0118 +2957, 68.32124, 127.4253 +2958, 65.81092, 123.0644 +2959, 68.90095, 119.241 +2960, 66.25545, 124.3161 +2961, 67.63532, 119.8268 +2962, 69.60217, 135.871 +2963, 69.19207, 129.4251 +2964, 68.12331, 116.5582 +2965, 67.47898, 116.8066 +2966, 66.24642, 113.4835 +2967, 68.50173, 121.5935 +2968, 62.87696, 102.6336 +2969, 65.24352, 109.5423 +2970, 69.99091, 136.7711 +2971, 68.75121, 125.0167 +2972, 66.26559, 132.9041 +2973, 67.33988, 137.9208 +2974, 66.08783, 128.0748 +2975, 69.10841, 141.3046 +2976, 68.02947, 136.2458 +2977, 71.4988, 144.147 +2978, 66.42022, 128.7172 +2979, 68.53037, 127.7893 +2980, 69.54256, 134.6098 +2981, 68.89587, 149.2571 +2982, 65.34144, 118.4045 +2983, 68.85953, 147.4612 +2984, 67.9932, 115.8792 +2985, 70.34681, 132.0704 +2986, 65.40868, 123.2475 +2987, 69.67377, 134.0875 +2988, 70.37964, 137.3754 +2989, 68.23626, 128.6996 +2990, 67.40948, 133.7103 +2991, 69.72564, 131.2636 +2992, 66.96911, 112.5541 +2993, 67.05246, 118.0263 +2994, 68.0873, 127.3013 +2995, 70.4947, 125.7998 +2996, 68.59715, 126.259 +2997, 66.45012, 119.3414 +2998, 67.24533, 122.5965 +2999, 69.22665, 135.3375 +3000, 68.4148, 137.2091 +3001, 70.51338, 143.7382 +3002, 70.63103, 145.4599 +3003, 69.83323, 133.1488 +3004, 69.76098, 132.4917 +3005, 68.11679, 126.8125 +3006, 66.53431, 120.2043 +3007, 71.0373, 127.177 +3008, 65.66484, 119.1195 +3009, 67.11404, 131.011 +3010, 70.93121, 151.9596 +3011, 68.25011, 147.9148 +3012, 67.04474, 120.1896 +3013, 69.40034, 121.6422 +3014, 68.35952, 131.7405 +3015, 65.7936, 105.584 +3016, 65.16867, 125.1514 +3017, 64.31223, 132.5808 +3018, 70.65237, 116.5383 +3019, 68.04397, 141.8528 +3020, 67.60186, 130.1925 +3021, 67.58242, 120.4606 +3022, 68.50821, 128.9264 +3023, 65.84079, 119.5386 +3024, 69.13492, 137.8896 +3025, 68.00897, 122.4403 +3026, 67.56761, 129.7133 +3027, 66.79775, 127.9067 +3028, 70.41567, 146.7498 +3029, 66.6532, 111.2623 +3030, 68.94427, 138.8701 +3031, 69.2921, 119.7773 +3032, 71.21679, 128.0274 +3033, 68.26773, 106.61 +3034, 65.73369, 113.3707 +3035, 63.63362, 106.5873 +3036, 69.44197, 125.085 +3037, 67.08087, 125.2055 +3038, 66.03614, 123.3208 +3039, 66.75256, 109.923 +3040, 69.05655, 129.0132 +3041, 66.02949, 108.5156 +3042, 67.62446, 138.1906 +3043, 66.54145, 121.1649 +3044, 71.4012, 133.5965 +3045, 68.54057, 132.5515 +3046, 66.23601, 123.6908 +3047, 71.74579, 148.3826 +3048, 64.8262, 124.0167 +3049, 69.13628, 150.4434 +3050, 63.85309, 113.5616 +3051, 65.88387, 118.8276 +3052, 70.20793, 152.1525 +3053, 69.83569, 121.8741 +3054, 66.51127, 127.3143 +3055, 71.09805, 147.2711 +3056, 64.60825, 112.4456 +3057, 70.23276, 137.7724 +3058, 64.68824, 108.5133 +3059, 67.16361, 124.8309 +3060, 69.32709, 133.656 +3061, 68.45934, 142.1525 +3062, 66.99209, 125.4821 +3063, 68.44693, 132.342 +3064, 67.41731, 128.0697 +3065, 69.21256, 120.7853 +3066, 65.23174, 129.8998 +3067, 65.42771, 117.499 +3068, 66.99225, 121.0608 +3069, 69.66303, 118.2405 +3070, 67.29207, 117.7533 +3071, 64.37238, 124.134 +3072, 68.90985, 106.8616 +3073, 70.80439, 124.5028 +3074, 68.7004, 129.2788 +3075, 68.29255, 113.5292 +3076, 65.50586, 125.7542 +3077, 68.97897, 121.0893 +3078, 69.65275, 125.5083 +3079, 69.49526, 133.7579 +3080, 66.61841, 131.7656 +3081, 64.46226, 117.407 +3082, 69.10304, 131.1557 +3083, 67.86149, 128.0879 +3084, 67.83106, 107.8007 +3085, 67.66576, 133.9987 +3086, 67.93384, 123.2716 +3087, 71.95735, 142.6244 +3088, 66.88443, 115.1191 +3089, 71.25927, 130.7929 +3090, 63.13444, 111.3605 +3091, 70.25703, 131.1771 +3092, 67.68872, 109.8541 +3093, 63.45505, 113.3017 +3094, 71.59334, 117.9625 +3095, 68.69094, 140.3001 +3096, 64.36556, 122.4675 +3097, 68.84021, 139.5953 +3098, 67.79238, 130.4642 +3099, 65.97475, 121.9744 +3100, 64.23339, 106.8916 +3101, 65.46597, 113.5834 +3102, 65.22202, 94.61233 +3103, 67.90056, 120.3075 +3104, 64.42244, 131.5245 +3105, 68.23998, 113.3743 +3106, 70.01671, 128.8175 +3107, 67.25105, 131.9522 +3108, 67.28007, 117.6487 +3109, 69.48821, 129.6283 +3110, 69.50486, 136.9585 +3111, 68.0898, 120.5675 +3112, 68.09624, 127.7017 +3113, 64.59835, 113.0571 +3114, 67.63863, 117.784 +3115, 69.07559, 145.8644 +3116, 65.43751, 123.7503 +3117, 66.04755, 116.2935 +3118, 67.38822, 113.2922 +3119, 68.74094, 121.8236 +3120, 66.68207, 132.4644 +3121, 67.10251, 116.5027 +3122, 68.72578, 148.798 +3123, 69.95585, 134.2309 +3124, 71.48969, 151.6437 +3125, 66.69291, 128.2832 +3126, 65.37967, 110.6266 +3127, 67.59507, 126.1888 +3128, 67.65455, 113.8593 +3129, 68.68263, 125.494 +3130, 69.58679, 125.2317 +3131, 68.37402, 123.4402 +3132, 67.93581, 131.6798 +3133, 65.44645, 133.7783 +3134, 68.37812, 117.4608 +3135, 70.02962, 134.5618 +3136, 66.48126, 125.3948 +3137, 69.02608, 114.1902 +3138, 69.55202, 144.8532 +3139, 64.80997, 132.2021 +3140, 65.70656, 107.7373 +3141, 65.72803, 140.2288 +3142, 68.21876, 121.7152 +3143, 65.86034, 125.5649 +3144, 65.16426, 126.6267 +3145, 66.96428, 135.9602 +3146, 63.75844, 105.6245 +3147, 69.96035, 146.4008 +3148, 69.29626, 106.2849 +3149, 65.18388, 117.985 +3150, 67.37365, 107.4966 +3151, 69.76312, 119.6316 +3152, 65.20697, 116.4881 +3153, 66.31364, 124.9947 +3154, 66.74365, 118.0293 +3155, 65.57241, 128.5441 +3156, 71.05515, 134.7298 +3157, 69.28167, 135.8658 +3158, 71.77797, 136.3061 +3159, 63.53338, 104.7024 +3160, 69.75851, 120.3953 +3161, 66.7395, 118.3091 +3162, 66.76099, 122.1245 +3163, 72.16716, 156.2465 +3164, 64.34648, 117.265 +3165, 69.25366, 128.9281 +3166, 68.20016, 129.2408 +3167, 67.84238, 131.1469 +3168, 70.54498, 136.6229 +3169, 65.25826, 110.8818 +3170, 67.78738, 115.5424 +3171, 66.79884, 132.1508 +3172, 68.13317, 137.9186 +3173, 67.48449, 123.0402 +3174, 70.4411, 148.7687 +3175, 68.33621, 123.88 +3176, 68.67946, 138.1734 +3177, 67.95136, 122.3842 +3178, 65.92021, 120.5629 +3179, 68.14026, 121.2805 +3180, 67.29912, 133.4119 +3181, 67.43318, 121.7736 +3182, 66.07076, 122.2608 +3183, 69.32562, 135.9047 +3184, 65.89875, 134.5927 +3185, 67.23868, 117.4154 +3186, 68.01261, 129.311 +3187, 68.62709, 122.403 +3188, 67.76031, 143.2106 +3189, 67.54784, 128.0734 +3190, 67.26315, 107.2961 +3191, 71.53453, 145.4266 +3192, 65.06551, 123.2535 +3193, 67.43465, 115.9394 +3194, 69.15557, 131.1976 +3195, 67.10856, 110.8966 +3196, 68.48481, 132.9513 +3197, 68.05629, 143.3736 +3198, 68.40527, 142.3615 +3199, 71.97264, 138.5403 +3200, 67.88635, 145.0092 +3201, 68.93287, 133.8419 +3202, 68.24127, 106.3258 +3203, 66.01267, 117.3092 +3204, 67.37485, 134.7795 +3205, 68.21364, 141.9627 +3206, 68.34543, 131.9721 +3207, 68.65931, 137.013 +3208, 68.84427, 144.7351 +3209, 69.03818, 143.485 +3210, 68.11385, 127.8782 +3211, 67.3109, 126.0281 +3212, 69.49562, 126.4439 +3213, 69.39962, 127.7448 +3214, 67.57502, 126.2983 +3215, 66.43096, 106.7579 +3216, 69.2189, 122.9471 +3217, 66.19304, 120.9485 +3218, 66.59157, 107.8202 +3219, 66.81548, 135.6921 +3220, 68.00225, 124.7943 +3221, 69.09045, 123.456 +3222, 68.6133, 133.9338 +3223, 71.62355, 157.659 +3224, 67.4363, 133.6369 +3225, 65.12769, 113.7514 +3226, 68.87788, 139.7284 +3227, 65.8284, 123.9196 +3228, 67.27468, 117.2019 +3229, 68.36412, 114.74 +3230, 67.98858, 135.5863 +3231, 69.99934, 130.2303 +3232, 66.73116, 132.3482 +3233, 67.47372, 116.7746 +3234, 65.0195, 122.0863 +3235, 71.12723, 147.136 +3236, 67.6698, 133.6517 +3237, 68.77095, 153.9969 +3238, 68.48264, 135.3549 +3239, 66.8768, 119.5152 +3240, 70.54119, 134.2581 +3241, 67.04893, 126.7798 +3242, 67.63647, 118.7652 +3243, 67.57626, 120.3951 +3244, 70.87537, 148.4787 +3245, 66.23513, 125.14 +3246, 67.01055, 121.4965 +3247, 67.64118, 129.0488 +3248, 67.9016, 134.8018 +3249, 69.31483, 136.4644 +3250, 68.22857, 119.5528 +3251, 66.98456, 135.7446 +3252, 67.00963, 126.1537 +3253, 69.95272, 144.3773 +3254, 65.80355, 99.51504 +3255, 68.92933, 134.0114 +3256, 67.70136, 136.4446 +3257, 67.91607, 133.3008 +3258, 66.84068, 131.6362 +3259, 69.99456, 135.2158 +3260, 66.4718, 118.2191 +3261, 64.18564, 111.0182 +3262, 66.246, 128.8387 +3263, 68.80963, 130.791 +3264, 67.65907, 128.573 +3265, 66.77115, 130.2165 +3266, 65.37953, 131.9436 +3267, 66.7844, 120.2342 +3268, 71.27461, 137.3123 +3269, 66.61529, 120.9979 +3270, 65.83005, 123.3074 +3271, 69.57158, 130.6931 +3272, 68.00656, 139.9829 +3273, 68.69628, 111.38 +3274, 66.42314, 124.9978 +3275, 66.99259, 122.1147 +3276, 67.96518, 129.2041 +3277, 68.66471, 116.8008 +3278, 66.61581, 110.2205 +3279, 67.63645, 131.1351 +3280, 70.31626, 139.0315 +3281, 69.75296, 124.5872 +3282, 67.08745, 124.9637 +3283, 68.16256, 127.0057 +3284, 68.10701, 134.1875 +3285, 69.7191, 155.7074 +3286, 66.6639, 109.6815 +3287, 69.21432, 142.3644 +3288, 64.6701, 125.2237 +3289, 67.6419, 116.4677 +3290, 70.95584, 129.5297 +3291, 67.68754, 129.9618 +3292, 68.39041, 131.11 +3293, 70.94659, 149.2299 +3294, 69.3929, 138.8501 +3295, 64.29056, 128.0364 +3296, 70.36687, 136.6274 +3297, 67.04642, 127.3941 +3298, 66.03627, 130.0724 +3299, 67.23901, 132.3301 +3300, 68.4523, 115.3808 +3301, 68.00298, 121.4437 +3302, 68.19927, 133.5988 +3303, 69.15154, 135.7115 +3304, 72.36766, 138.8835 +3305, 70.17575, 138.5825 +3306, 66.89187, 130.3881 +3307, 67.86089, 130.8938 +3308, 69.3241, 126.4663 +3309, 68.85085, 125.6815 +3310, 63.59867, 108.3695 +3311, 67.68177, 146.0547 +3312, 65.92195, 128.9527 +3313, 66.04233, 138.9407 +3314, 68.07077, 136.7048 +3315, 68.53269, 136.9208 +3316, 66.41329, 121.4656 +3317, 67.6551, 139.0278 +3318, 69.39574, 124.2868 +3319, 70.72068, 135.4026 +3320, 69.39895, 127.7865 +3321, 68.70993, 134.9467 +3322, 69.38351, 130.8867 +3323, 69.01409, 133.5517 +3324, 68.84671, 121.2891 +3325, 66.67972, 130.3173 +3326, 64.14012, 136.6169 +3327, 65.45315, 120.6706 +3328, 67.16684, 132.1766 +3329, 67.52493, 124.0382 +3330, 67.17756, 133.8366 +3331, 66.73401, 131.714 +3332, 70.0236, 117.9912 +3333, 67.17283, 116.4658 +3334, 65.18918, 138.7007 +3335, 68.32763, 127.9768 +3336, 72.55002, 139.9074 +3337, 70.71251, 148.0151 +3338, 70.88049, 140.65 +3339, 66.96285, 130.6093 +3340, 69.82684, 143.0451 +3341, 65.16431, 128.951 +3342, 68.23622, 140.5259 +3343, 66.73023, 142.5733 +3344, 72.29547, 138.9453 +3345, 69.16314, 127.5533 +3346, 67.56202, 115.1545 +3347, 65.7718, 119.6649 +3348, 67.4295, 100.7527 +3349, 67.235, 122.7841 +3350, 69.86435, 146.7835 +3351, 71.88676, 144.7958 +3352, 68.87227, 138.991 +3353, 70.04608, 137.0023 +3354, 68.73409, 137.8343 +3355, 69.03486, 138.8044 +3356, 69.26447, 128.3303 +3357, 70.09459, 124.8418 +3358, 70.12595, 131.6374 +3359, 66.54739, 120.0134 +3360, 66.3726, 117.0774 +3361, 65.72273, 113.9648 +3362, 67.65602, 126.6406 +3363, 64.69649, 108.3562 +3364, 66.41005, 127.2142 +3365, 69.27872, 134.603 +3366, 68.63208, 121.5365 +3367, 68.60374, 145.1284 +3368, 70.38104, 135.204 +3369, 69.28461, 127.5704 +3370, 71.64455, 153.6515 +3371, 70.37091, 155.869 +3372, 65.45196, 121.4609 +3373, 69.65595, 133.8526 +3374, 67.69863, 108.9521 +3375, 70.04255, 130.5425 +3376, 67.69758, 124.0931 +3377, 66.856, 132.5109 +3378, 69.87691, 154.5701 +3379, 68.5184, 124.004 +3380, 67.68314, 127.6985 +3381, 67.61985, 114.26 +3382, 69.25373, 142.7731 +3383, 68.98349, 115.897 +3384, 66.98194, 125.1081 +3385, 63.41013, 119.8153 +3386, 68.3495, 127.3052 +3387, 70.14263, 130.255 +3388, 67.67369, 125.3486 +3389, 67.83046, 118.0148 +3390, 71.15629, 129.468 +3391, 70.04469, 138.4503 +3392, 69.45013, 138.6964 +3393, 67.78201, 134.9735 +3394, 65.27229, 119.6325 +3395, 69.44983, 132.0852 +3396, 67.90892, 132.1945 +3397, 68.1636, 146.9576 +3398, 66.37934, 112.0144 +3399, 68.73896, 129.7229 +3400, 69.75201, 128.9392 +3401, 69.44655, 125.5484 +3402, 64.92283, 102.8549 +3403, 64.80108, 119.4034 +3404, 65.84217, 143.8547 +3405, 68.34828, 129.9632 +3406, 68.13534, 125.1662 +3407, 66.32414, 126.9552 +3408, 70.74868, 112.1237 +3409, 67.48997, 115.0831 +3410, 65.8077, 120.0188 +3411, 67.41008, 122.7409 +3412, 68.39969, 133.5177 +3413, 72.19938, 144.1058 +3414, 71.65513, 146.9261 +3415, 70.19523, 134.0839 +3416, 65.92306, 112.9231 +3417, 73.35034, 142.4875 +3418, 64.21849, 121.3899 +3419, 65.70466, 122.7506 +3420, 68.90463, 136.1054 +3421, 68.06195, 127.8162 +3422, 66.85163, 139.0505 +3423, 69.58698, 124.5701 +3424, 69.42478, 126.8527 +3425, 68.02716, 145.8616 +3426, 71.71699, 136.8975 +3427, 66.95183, 133.4618 +3428, 69.74699, 122.1901 +3429, 68.80049, 115.6403 +3430, 67.89371, 125.377 +3431, 68.57659, 129.2547 +3432, 68.72581, 129.1874 +3433, 69.63584, 133.0704 +3434, 68.9713, 138.0269 +3435, 66.8827, 118.8532 +3436, 69.21469, 142.7606 +3437, 67.98056, 126.2747 +3438, 68.56045, 119.1386 +3439, 67.92182, 117.0603 +3440, 69.15108, 120.454 +3441, 69.09773, 132.1603 +3442, 66.92076, 108.7441 +3443, 67.43796, 106.5115 +3444, 67.67848, 130.2144 +3445, 70.02323, 140.4403 +3446, 67.78297, 124.5214 +3447, 72.83169, 139.3706 +3448, 68.05868, 129.4378 +3449, 67.44814, 129.0994 +3450, 65.57065, 118.2219 +3451, 67.59465, 117.6786 +3452, 67.82155, 140.8622 +3453, 68.47258, 122.6694 +3454, 63.58771, 104.467 +3455, 67.95929, 129.0106 +3456, 65.22442, 124.3217 +3457, 66.44894, 101.9139 +3458, 67.33704, 139.416 +3459, 65.69507, 132.7342 +3460, 70.72749, 132.8116 +3461, 67.41511, 124.3421 +3462, 69.76325, 126.7586 +3463, 65.37021, 119.848 +3464, 70.00296, 111.9376 +3465, 66.22804, 117.26 +3466, 71.01952, 131.8577 +3467, 66.66825, 122.6517 +3468, 65.766, 117.0445 +3469, 69.19585, 117.8609 +3470, 66.01043, 130.8876 +3471, 65.81063, 124.3575 +3472, 69.63647, 131.0505 +3473, 67.20188, 142.083 +3474, 67.84033, 100.3696 +3475, 63.55149, 127.0979 +3476, 68.31141, 124.2054 +3477, 65.48001, 116.5552 +3478, 69.58827, 123.5653 +3479, 66.1176, 111.8548 +3480, 71.49457, 150.1752 +3481, 70.91224, 128.172 +3482, 65.08904, 120.4457 +3483, 66.85324, 110.6689 +3484, 67.33053, 135.7821 +3485, 70.41812, 145.8887 +3486, 70.74812, 144.6908 +3487, 69.897, 128.3047 +3488, 68.29767, 137.1886 +3489, 67.83703, 127.2593 +3490, 65.24423, 122.1945 +3491, 67.84894, 139.6043 +3492, 70.42564, 129.817 +3493, 70.55525, 152.9847 +3494, 67.88636, 123.5425 +3495, 69.7096, 137.7755 +3496, 67.07269, 116.3106 +3497, 71.88822, 125.4909 +3498, 71.28254, 134.9234 +3499, 66.61757, 116.9673 +3500, 69.33248, 131.029 +3501, 69.17119, 138.2493 +3502, 68.93099, 117.0109 +3503, 65.39211, 117.1889 +3504, 66.40145, 133.3265 +3505, 65.97157, 121.4286 +3506, 65.61777, 122.2767 +3507, 67.1943, 129.2964 +3508, 65.74682, 106.9673 +3509, 64.34058, 118.7342 +3510, 65.27557, 112.0218 +3511, 71.37011, 133.4833 +3512, 68.13757, 127.5429 +3513, 72.05393, 131.366 +3514, 65.7047, 114.9957 +3515, 67.07598, 125.5866 +3516, 63.96935, 84.86345 +3517, 65.26358, 129.4427 +3518, 65.97301, 126.9647 +3519, 68.28892, 139.8538 +3520, 65.81249, 120.6804 +3521, 64.11914, 127.4184 +3522, 67.02094, 120.0865 +3523, 69.03252, 132.7904 +3524, 68.99289, 123.4864 +3525, 64.41882, 114.4503 +3526, 67.15633, 112.938 +3527, 68.76733, 116.9251 +3528, 69.01892, 133.9261 +3529, 66.76233, 128.2645 +3530, 68.18232, 107.0685 +3531, 67.28745, 128.2196 +3532, 68.65317, 126.5592 +3533, 71.06665, 125.8611 +3534, 70.31177, 134.6115 +3535, 72.4691, 152.1181 +3536, 68.8736, 135.5056 +3537, 64.68847, 115.9514 +3538, 68.1288, 127.6565 +3539, 67.36526, 141.0621 +3540, 65.60339, 109.572 +3541, 68.0437, 122.3788 +3542, 69.28083, 134.2059 +3543, 68.87006, 134.8058 +3544, 68.5515, 108.4165 +3545, 70.402, 121.5254 +3546, 70.89245, 131.4848 +3547, 63.57508, 112.824 +3548, 69.96784, 129.2959 +3549, 69.86404, 144.6551 +3550, 67.43349, 123.2584 +3551, 65.953, 130.0755 +3552, 66.51685, 97.84025 +3553, 66.59374, 133.7803 +3554, 64.82036, 106.5226 +3555, 68.76391, 139.4665 +3556, 67.24653, 116.868 +3557, 67.62134, 133.7579 +3558, 66.16322, 118.9108 +3559, 67.42497, 122.3291 +3560, 68.65199, 127.3678 +3561, 67.41315, 114.0066 +3562, 68.24549, 137.0083 +3563, 66.02486, 110.0077 +3564, 65.25809, 132.9911 +3565, 69.91392, 132.3932 +3566, 65.79089, 117.5234 +3567, 67.71449, 130.4334 +3568, 68.29458, 117.7587 +3569, 65.61141, 117.7477 +3570, 67.78179, 129.0761 +3571, 64.30338, 105.6364 +3572, 67.30706, 131.7766 +3573, 68.96485, 131.8757 +3574, 64.97931, 125.9879 +3575, 69.07887, 123.8861 +3576, 67.39433, 133.0366 +3577, 67.27351, 131.1858 +3578, 67.64179, 126.7371 +3579, 70.45489, 151.614 +3580, 69.09422, 147.1926 +3581, 66.0667, 134.7624 +3582, 67.70438, 133.445 +3583, 66.985, 111.2501 +3584, 65.46653, 117.0386 +3585, 68.69845, 129.8079 +3586, 66.04072, 99.27518 +3587, 66.09431, 128.5692 +3588, 69.80498, 151.548 +3589, 67.73859, 139.3895 +3590, 66.68205, 120.0516 +3591, 68.9189, 124.0676 +3592, 67.06468, 137.5999 +3593, 65.256, 129.4912 +3594, 68.3313, 139.801 +3595, 68.39086, 148.5226 +3596, 67.84685, 120.6246 +3597, 66.37815, 138.6642 +3598, 63.32113, 92.37513 +3599, 66.57084, 136.5421 +3600, 67.88983, 118.2089 +3601, 70.94094, 138.6145 +3602, 69.91224, 135.6715 +3603, 64.89822, 104.5861 +3604, 69.46685, 128.2748 +3605, 68.56738, 125.4858 +3606, 66.53162, 143.8794 +3607, 68.6378, 125.3511 +3608, 70.90025, 126.3358 +3609, 71.26396, 139.7274 +3610, 67.13527, 116.2366 +3611, 64.80236, 97.79781 +3612, 70.67036, 136.8521 +3613, 66.13501, 112.7896 +3614, 64.77081, 112.5529 +3615, 68.35648, 120.7636 +3616, 68.24493, 119.3536 +3617, 67.7318, 135.4753 +3618, 67.04488, 140.4543 +3619, 69.94917, 142.0555 +3620, 64.50981, 126.8512 +3621, 67.87716, 123.1267 +3622, 68.61556, 118.3477 +3623, 68.08104, 134.5331 +3624, 66.35068, 116.8814 +3625, 66.71224, 108.9156 +3626, 71.16146, 134.9529 +3627, 64.76054, 109.5924 +3628, 66.75144, 106.5216 +3629, 66.73685, 119.4936 +3630, 69.68151, 137.7906 +3631, 70.72413, 151.0354 +3632, 68.34441, 121.4853 +3633, 67.6858, 146.7791 +3634, 66.98729, 140.0306 +3635, 69.43833, 116.5077 +3636, 70.35311, 140.7913 +3637, 68.29063, 140.0969 +3638, 69.81605, 131.6661 +3639, 68.07763, 144.0462 +3640, 69.63007, 136.5389 +3641, 67.94658, 124.5183 +3642, 66.66861, 123.3439 +3643, 72.54964, 140.3326 +3644, 65.96495, 125.1353 +3645, 68.73999, 142.2247 +3646, 73.25271, 156.3537 +3647, 63.8433, 113.8671 +3648, 66.96921, 120.7632 +3649, 67.68747, 120.6478 +3650, 66.81228, 139.8202 +3651, 66.72332, 119.0638 +3652, 68.9021, 141.0105 +3653, 69.92563, 143.4254 +3654, 69.85536, 133.5108 +3655, 69.32382, 137.0878 +3656, 66.59092, 121.7154 +3657, 68.85426, 127.9174 +3658, 66.54029, 113.4724 +3659, 65.65814, 128.0828 +3660, 69.30998, 131.776 +3661, 70.17204, 138.2634 +3662, 67.97014, 125.758 +3663, 66.85274, 120.3874 +3664, 67.93626, 129.0463 +3665, 72.43693, 136.391 +3666, 67.58597, 130.0804 +3667, 68.61381, 118.5302 +3668, 70.42389, 129.8475 +3669, 66.40833, 119.5325 +3670, 70.57091, 138.3516 +3671, 69.79777, 128.9593 +3672, 67.34701, 116.8005 +3673, 66.40224, 123.1326 +3674, 64.68881, 116.9304 +3675, 69.53955, 126.5974 +3676, 69.43648, 141.1934 +3677, 69.36832, 131.6094 +3678, 67.02639, 109.3029 +3679, 68.60035, 116.408 +3680, 64.90605, 101.3305 +3681, 73.6704, 147.9165 +3682, 68.37014, 141.2402 +3683, 68.3104, 138.8869 +3684, 64.51584, 148.5007 +3685, 66.12992, 101.0513 +3686, 65.38495, 125.7223 +3687, 65.11549, 106.3269 +3688, 67.05783, 126.3894 +3689, 66.99532, 134.2725 +3690, 67.08079, 125.6528 +3691, 65.28833, 113.2531 +3692, 68.09544, 119.5911 +3693, 66.6868, 116.2576 +3694, 68.33953, 143.6987 +3695, 66.84266, 112.5571 +3696, 68.83968, 131.1388 +3697, 61.8934, 95.74545 +3698, 65.73799, 113.6203 +3699, 68.72588, 141.3191 +3700, 67.8244, 116.9133 +3701, 67.01202, 124.2022 +3702, 65.5611, 117.5665 +3703, 67.55321, 119.2307 +3704, 67.1303, 114.5048 +3705, 67.64061, 130.0058 +3706, 66.83182, 140.4851 +3707, 68.27516, 144.0058 +3708, 69.44828, 131.2024 +3709, 69.58545, 126.2305 +3710, 66.7071, 104.6225 +3711, 68.19325, 121.5126 +3712, 69.13191, 135.9547 +3713, 66.59378, 136.2738 +3714, 66.48656, 131.7593 +3715, 66.37289, 118.7403 +3716, 70.71575, 139.42 +3717, 67.15897, 129.0818 +3718, 67.76901, 114.4204 +3719, 65.18164, 113.1913 +3720, 67.83932, 112.5536 +3721, 68.0491, 157.6543 +3722, 68.58692, 121.5904 +3723, 65.95317, 119.206 +3724, 71.02002, 136.1093 +3725, 69.2108, 116.8245 +3726, 67.16712, 133.9377 +3727, 64.82773, 119.5375 +3728, 71.89734, 125.1534 +3729, 66.29137, 119.6552 +3730, 69.63011, 136.2859 +3731, 66.65205, 112.4741 +3732, 70.56251, 132.5837 +3733, 67.79995, 131.5466 +3734, 68.74825, 128.4833 +3735, 66.84629, 137.0769 +3736, 67.47997, 112.9767 +3737, 67.13893, 124.5135 +3738, 68.40021, 138.2798 +3739, 68.86099, 136.6706 +3740, 66.17409, 119.2702 +3741, 68.84978, 131.2561 +3742, 68.67678, 129.8508 +3743, 69.82135, 156.1101 +3744, 64.2599, 108.0741 +3745, 69.71651, 136.2846 +3746, 70.94085, 136.9681 +3747, 70.06779, 139.4128 +3748, 70.88342, 135.7171 +3749, 65.49529, 118.6689 +3750, 68.4804, 138.799 +3751, 68.51303, 138.9157 +3752, 68.16142, 118.2547 +3753, 71.95866, 135.3357 +3754, 64.75487, 129.262 +3755, 70.30789, 135.1908 +3756, 67.4222, 115.1791 +3757, 68.24432, 112.2308 +3758, 68.24598, 122.3013 +3759, 68.67772, 128.2031 +3760, 69.45147, 157.3486 +3761, 67.00023, 128.2287 +3762, 68.53583, 115.0374 +3763, 68.09648, 149.9119 +3764, 66.8815, 118.7213 +3765, 64.35721, 111.8923 +3766, 64.95432, 119.5408 +3767, 68.10575, 121.9841 +3768, 66.80947, 111.1912 +3769, 63.88864, 112.1842 +3770, 67.38665, 106.1061 +3771, 68.92239, 132.2605 +3772, 68.34907, 118.027 +3773, 65.8834, 131.8548 +3774, 65.81926, 122.7493 +3775, 67.6519, 126.4083 +3776, 69.91178, 135.567 +3777, 69.43847, 144.6145 +3778, 68.6245, 133.9108 +3779, 68.5874, 139.0597 +3780, 69.96201, 143.3765 +3781, 68.48251, 133.9215 +3782, 70.14044, 132.9707 +3783, 67.69318, 151.5436 +3784, 69.74263, 140.4279 +3785, 64.14704, 115.8887 +3786, 71.15494, 146.3078 +3787, 70.42127, 135.2438 +3788, 69.4086, 130.0152 +3789, 67.23391, 113.361 +3790, 69.52859, 109.7608 +3791, 69.78153, 155.0882 +3792, 65.86011, 116.5987 +3793, 68.53242, 115.8963 +3794, 69.43053, 123.8453 +3795, 70.51721, 132.1602 +3796, 72.46195, 150.0174 +3797, 70.57152, 123.4049 +3798, 64.81039, 113.7813 +3799, 69.14193, 124.9768 +3800, 72.59694, 140.1938 +3801, 67.29902, 125.6349 +3802, 69.3501, 124.6512 +3803, 69.0374, 115.7152 +3804, 71.50733, 147.7946 +3805, 68.58383, 123.7158 +3806, 68.9172, 137.4837 +3807, 69.94709, 119.3727 +3808, 68.63514, 111.791 +3809, 68.30987, 140.6815 +3810, 68.95399, 142.1807 +3811, 65.52576, 130.6623 +3812, 66.58753, 131.0557 +3813, 69.43486, 118.7635 +3814, 70.6428, 147.6001 +3815, 68.57866, 140.395 +3816, 68.1007, 129.3231 +3817, 70.56771, 125.4514 +3818, 64.97452, 107.0565 +3819, 67.85384, 128.0846 +3820, 71.17071, 131.245 +3821, 67.67057, 112.3113 +3822, 66.04283, 106.7968 +3823, 68.89472, 125.9164 +3824, 66.42827, 138.7008 +3825, 69.42646, 137.7593 +3826, 62.6568, 110.266 +3827, 65.79319, 128.2726 +3828, 71.35208, 150.3381 +3829, 68.54117, 120.4207 +3830, 66.64205, 118.7461 +3831, 67.1013, 132.3003 +3832, 68.09912, 122.8586 +3833, 67.44749, 116.2164 +3834, 68.5689, 105.9279 +3835, 66.74451, 111.2084 +3836, 67.91191, 115.9255 +3837, 67.61468, 132.6425 +3838, 66.79956, 128.7716 +3839, 66.08205, 105.5009 +3840, 69.43398, 130.8951 +3841, 70.06177, 159.8542 +3842, 67.34245, 113.1131 +3843, 65.68008, 104.7032 +3844, 67.65289, 130.0791 +3845, 72.35481, 146.3133 +3846, 64.56198, 117.9061 +3847, 66.56321, 125.872 +3848, 71.88064, 138.7186 +3849, 69.05855, 119.1382 +3850, 68.84729, 130.1311 +3851, 68.33558, 127.2486 +3852, 67.20373, 120.0823 +3853, 66.94024, 116.7898 +3854, 65.6925, 112.1004 +3855, 70.55858, 137.4236 +3856, 66.3239, 112.1502 +3857, 66.31961, 141.3789 +3858, 68.77019, 121.7461 +3859, 68.93596, 130.3465 +3860, 70.19784, 129.2123 +3861, 69.15846, 141.6059 +3862, 66.52917, 107.7722 +3863, 69.76951, 141.4952 +3864, 68.33707, 112.1581 +3865, 66.71052, 116.3208 +3866, 64.93669, 128.5199 +3867, 65.06581, 102.9057 +3868, 67.19588, 114.4447 +3869, 65.6155, 114.5452 +3870, 68.21154, 115.0009 +3871, 71.8127, 151.5781 +3872, 65.23439, 118.7079 +3873, 67.84537, 132.6379 +3874, 66.17647, 115.3378 +3875, 69.61315, 133.5897 +3876, 66.18245, 132.5006 +3877, 67.84508, 134.514 +3878, 69.0936, 126.1625 +3879, 66.12316, 131.3628 +3880, 65.15822, 116.0727 +3881, 69.79407, 141.3766 +3882, 67.00234, 127.3607 +3883, 69.13726, 140.2001 +3884, 65.81826, 126.6507 +3885, 68.20344, 121.9858 +3886, 66.89907, 134.2045 +3887, 65.04452, 102.086 +3888, 66.1717, 117.7314 +3889, 62.93166, 114.6211 +3890, 64.48357, 117.4963 +3891, 66.64624, 111.7542 +3892, 72.41441, 151.933 +3893, 71.79969, 122.983 +3894, 65.66078, 123.3884 +3895, 66.93932, 107.7347 +3896, 70.22759, 138.8617 +3897, 68.20998, 130.7491 +3898, 67.03876, 108.817 +3899, 70.72651, 119.7924 +3900, 67.43797, 132.67 +3901, 69.02832, 144.247 +3902, 71.08333, 130.1898 +3903, 66.59033, 119.8506 +3904, 62.84458, 112.1475 +3905, 65.01513, 112.6016 +3906, 68.89573, 126.6749 +3907, 67.52318, 120.368 +3908, 71.56209, 136.2017 +3909, 69.91081, 114.942 +3910, 65.74474, 116.1331 +3911, 67.86476, 131.3966 +3912, 69.34915, 126.219 +3913, 66.56305, 126.8313 +3914, 64.98952, 106.6708 +3915, 66.28774, 136.3548 +3916, 68.22623, 144.8283 +3917, 68.71834, 121.2425 +3918, 67.34642, 113.9096 +3919, 69.45129, 133.1979 +3920, 68.58821, 118.7312 +3921, 67.13792, 139.5328 +3922, 66.17703, 122.4766 +3923, 65.11882, 136.7334 +3924, 68.98184, 162.1526 +3925, 69.70654, 116.1377 +3926, 65.9028, 116.3873 +3927, 66.40799, 122.7559 +3928, 69.68697, 125.8107 +3929, 71.32231, 127.1985 +3930, 69.39616, 126.21 +3931, 67.10007, 127.4093 +3932, 64.84823, 121.4686 +3933, 65.97406, 120.1281 +3934, 69.40242, 130.8887 +3935, 70.24875, 148.6699 +3936, 66.76364, 108.979 +3937, 68.54135, 132.1438 +3938, 72.31585, 145.2904 +3939, 66.13369, 124.1218 +3940, 65.52533, 106.0457 +3941, 66.8421, 140.4934 +3942, 68.54828, 122.1607 +3943, 67.23496, 135.7089 +3944, 67.89102, 137.9068 +3945, 67.07543, 123.7723 +3946, 68.87056, 131.1289 +3947, 65.48833, 127.832 +3948, 66.94598, 131.0884 +3949, 67.94876, 116.698 +3950, 65.11113, 139.1882 +3951, 69.22852, 144.2813 +3952, 68.87917, 117.3348 +3953, 69.73424, 127.2578 +3954, 70.79565, 138.2181 +3955, 68.12213, 143.3238 +3956, 67.55313, 122.4926 +3957, 66.07053, 137.4736 +3958, 66.64782, 113.759 +3959, 67.54927, 135.4559 +3960, 67.41612, 111.8086 +3961, 64.1913, 123.1259 +3962, 67.52166, 133.1484 +3963, 65.95635, 107.8398 +3964, 67.61855, 125.8836 +3965, 65.95909, 129.0219 +3966, 69.49194, 113.9079 +3967, 67.69417, 134.568 +3968, 64.78748, 127.7878 +3969, 71.3001, 139.1262 +3970, 66.61133, 112.8285 +3971, 66.40129, 121.8472 +3972, 70.76906, 124.1304 +3973, 68.70195, 118.0629 +3974, 69.27545, 135.7574 +3975, 67.14179, 109.264 +3976, 69.40629, 144.7036 +3977, 69.69594, 142.5173 +3978, 67.20823, 137.1694 +3979, 67.59632, 113.3993 +3980, 70.77557, 144.7135 +3981, 66.95587, 128.8462 +3982, 67.91794, 117.0118 +3983, 65.76874, 116.0326 +3984, 69.03038, 132.8327 +3985, 67.53969, 134.5132 +3986, 64.10668, 124.705 +3987, 68.20174, 128.7712 +3988, 68.42812, 135.5603 +3989, 70.21228, 146.5841 +3990, 68.22553, 123.0704 +3991, 67.75587, 132.6394 +3992, 70.5536, 139.4887 +3993, 67.1115, 130.7106 +3994, 66.50872, 102.3817 +3995, 67.80339, 121.6264 +3996, 66.82898, 114.8121 +3997, 66.51285, 117.0249 +3998, 68.00268, 116.0381 +3999, 67.30483, 116.7343 +4000, 67.32611, 119.0783 +4001, 69.00102, 126.7983 +4002, 67.75162, 131.9365 +4003, 67.085, 135.9003 +4004, 69.0139, 151.5006 +4005, 66.13638, 143.9136 +4006, 66.74555, 131.5241 +4007, 66.32903, 130.233 +4008, 65.30345, 123.9503 +4009, 69.79829, 126.6311 +4010, 67.5243, 115.4643 +4011, 71.02928, 148.2436 +4012, 69.46091, 129.9518 +4013, 69.36777, 135.4124 +4014, 68.57098, 141.1859 +4015, 62.44964, 109.5643 +4016, 68.97793, 124.3412 +4017, 65.21731, 118.4281 +4018, 67.07967, 126.0679 +4019, 68.77673, 132.1985 +4020, 68.66629, 132.1617 +4021, 65.65796, 121.8407 +4022, 67.81659, 147.0148 +4023, 68.49369, 135.6229 +4024, 67.72209, 131.8871 +4025, 67.18182, 149.6975 +4026, 68.74487, 132.2867 +4027, 70.54344, 145.1882 +4028, 67.49034, 113.6369 +4029, 70.04011, 121.888 +4030, 66.14103, 131.9355 +4031, 63.03853, 116.7342 +4032, 65.8375, 113.1662 +4033, 70.09381, 132.9761 +4034, 65.46276, 101.8479 +4035, 66.72609, 119.4606 +4036, 67.15508, 126.3196 +4037, 67.89972, 116.5061 +4038, 66.83955, 124.3345 +4039, 66.33542, 137.2975 +4040, 69.98947, 157.9877 +4041, 69.19394, 136.793 +4042, 71.8433, 144.8892 +4043, 67.96111, 116.363 +4044, 67.8762, 125.536 +4045, 64.85023, 109.135 +4046, 71.00028, 128.7879 +4047, 68.9177, 148.7167 +4048, 68.11801, 108.4191 +4049, 68.45508, 120.7972 +4050, 66.1659, 119.9403 +4051, 68.09431, 141.8006 +4052, 67.04148, 116.4363 +4053, 67.9941, 136.4958 +4054, 70.03532, 162.0645 +4055, 69.71898, 137.99 +4056, 66.11294, 127.9705 +4057, 66.512, 124.0973 +4058, 72.14119, 147.0929 +4059, 66.26162, 136.034 +4060, 68.6341, 134.9883 +4061, 67.01999, 108.4088 +4062, 68.50946, 115.87 +4063, 66.65107, 132.7811 +4064, 69.13504, 150.0321 +4065, 66.3268, 124.4084 +4066, 69.03467, 125.2378 +4067, 68.41501, 131.125 +4068, 68.81498, 120.474 +4069, 69.71434, 126.7877 +4070, 69.71611, 119.4332 +4071, 68.46316, 121.7583 +4072, 66.76387, 127.8974 +4073, 65.40254, 113.6724 +4074, 70.56984, 123.8685 +4075, 65.94172, 123.6931 +4076, 68.02141, 122.0341 +4077, 67.1732, 114.7014 +4078, 65.497, 117.2034 +4079, 67.67185, 121.3213 +4080, 65.52488, 125.4382 +4081, 71.02076, 138.2195 +4082, 66.22083, 130.9358 +4083, 68.98001, 115.4355 +4084, 66.95762, 137.2853 +4085, 67.11276, 127.0824 +4086, 68.4405, 129.3152 +4087, 67.69709, 131.4005 +4088, 63.22395, 116.1956 +4089, 65.22711, 127.0613 +4090, 68.43, 131.3423 +4091, 66.57506, 121.9677 +4092, 63.5966, 113.2103 +4093, 67.20354, 123.3458 +4094, 66.03224, 99.66224 +4095, 67.24122, 124.0545 +4096, 66.79748, 130.086 +4097, 68.48589, 137.1664 +4098, 69.29654, 141.1792 +4099, 66.60912, 101.7777 +4100, 66.26464, 128.8128 +4101, 69.37333, 129.9046 +4102, 67.3275, 127.3943 +4103, 63.91658, 113.9444 +4104, 67.23806, 103.9784 +4105, 65.93291, 117.1245 +4106, 70.35586, 135.3823 +4107, 68.57141, 131.0931 +4108, 66.82713, 130.6498 +4109, 64.43271, 119.4229 +4110, 71.08973, 127.4216 +4111, 72.07911, 124.3172 +4112, 68.90533, 114.8714 +4113, 68.44145, 121.075 +4114, 68.46055, 115.3401 +4115, 65.13343, 106.3017 +4116, 71.17466, 131.6919 +4117, 69.39047, 139.886 +4118, 66.81513, 118.6787 +4119, 68.62714, 121.1908 +4120, 68.09304, 134.8095 +4121, 68.22911, 128.3543 +4122, 67.79469, 135.8259 +4123, 67.60704, 127.516 +4124, 70.47713, 135.5209 +4125, 68.89196, 119.3961 +4126, 67.18902, 141.7312 +4127, 69.52776, 138.0107 +4128, 64.00428, 106.2963 +4129, 67.23705, 129.0392 +4130, 66.57904, 110.0436 +4131, 73.08886, 143.597 +4132, 70.23666, 135.6427 +4133, 65.9154, 120.8619 +4134, 70.20771, 129.7829 +4135, 65.25899, 110.1349 +4136, 67.70538, 122.3278 +4137, 66.65382, 125.1019 +4138, 66.90522, 121.2072 +4139, 69.73584, 135.8864 +4140, 68.71515, 120.8681 +4141, 65.97593, 125.6805 +4142, 66.04025, 129.139 +4143, 69.22349, 147.1694 +4144, 68.01411, 124.9845 +4145, 70.44079, 141.5704 +4146, 66.62715, 138.6126 +4147, 68.47642, 126.7582 +4148, 68.20132, 134.1926 +4149, 69.18686, 148.1132 +4150, 66.55515, 122.4609 +4151, 67.24936, 125.9051 +4152, 68.23976, 134.1521 +4153, 68.93236, 140.8846 +4154, 69.16831, 127.3274 +4155, 68.15988, 127.5146 +4156, 70.47785, 135.4777 +4157, 71.46159, 134.7474 +4158, 69.56493, 139.1714 +4159, 72.04678, 147.9343 +4160, 68.11706, 122.1187 +4161, 67.11974, 136.1107 +4162, 65.25882, 112.8949 +4163, 67.9316, 127.1332 +4164, 68.62153, 134.6362 +4165, 68.96662, 110.1335 +4166, 67.70641, 137.8451 +4167, 64.82138, 132.6417 +4168, 69.74734, 130.7984 +4169, 67.83743, 126.8633 +4170, 66.47424, 119.564 +4171, 70.29564, 136.1613 +4172, 67.99529, 136.5186 +4173, 71.46156, 132.6211 +4174, 66.73734, 114.2795 +4175, 66.34826, 116.7421 +4176, 69.25165, 137.7726 +4177, 67.54427, 130.0454 +4178, 70.67379, 135.7083 +4179, 67.30702, 135.6941 +4180, 64.62951, 101.3328 +4181, 66.57405, 130.5342 +4182, 69.29679, 137.3539 +4183, 69.27554, 121.0292 +4184, 69.50607, 120.3639 +4185, 68.26403, 141.0864 +4186, 69.86553, 139.0365 +4187, 70.7672, 136.4844 +4188, 69.24893, 142.8621 +4189, 67.01021, 104.1735 +4190, 69.1245, 145.5379 +4191, 71.27947, 120.9881 +4192, 74.03777, 139.5953 +4193, 67.16426, 120.8184 +4194, 69.16282, 125.9266 +4195, 68.09796, 126.298 +4196, 67.77952, 133.2805 +4197, 71.11526, 123.3401 +4198, 64.98837, 105.6441 +4199, 70.31512, 142.3548 +4200, 69.06438, 130.4546 +4201, 65.46827, 110.4915 +4202, 65.9316, 114.9535 +4203, 68.42739, 133.4786 +4204, 70.30053, 139.3092 +4205, 67.09535, 129.4262 +4206, 68.43342, 121.8407 +4207, 65.83898, 136.3506 +4208, 67.54012, 143.6547 +4209, 68.48012, 126.9991 +4210, 71.57695, 139.6645 +4211, 69.72167, 139.1423 +4212, 66.29363, 126.9897 +4213, 68.937, 142.7584 +4214, 71.41489, 149.8921 +4215, 69.62838, 143.7861 +4216, 71.18773, 152.4615 +4217, 68.30221, 143.546 +4218, 67.75946, 152.9883 +4219, 68.11064, 133.9839 +4220, 69.47284, 135.5993 +4221, 70.16644, 134.6592 +4222, 67.64262, 124.1779 +4223, 66.81134, 118.271 +4224, 64.94018, 121.7107 +4225, 65.36721, 121.3633 +4226, 68.54428, 133.1727 +4227, 67.97819, 114.8234 +4228, 68.34252, 137.7084 +4229, 68.31923, 122.5531 +4230, 66.1507, 105.4808 +4231, 67.80629, 119.5263 +4232, 70.13434, 135.1981 +4233, 65.63247, 122.1851 +4234, 65.52678, 114.9083 +4235, 68.04573, 136.5998 +4236, 68.17956, 143.4398 +4237, 66.65253, 103.9121 +4238, 68.05725, 133.6935 +4239, 67.34998, 119.11 +4240, 70.00498, 129.4393 +4241, 66.55749, 127.0247 +4242, 66.82552, 144.7401 +4243, 70.07322, 123.0627 +4244, 65.9202, 126.0649 +4245, 69.54043, 147.8452 +4246, 63.89592, 117.0034 +4247, 69.03457, 131.5836 +4248, 67.22877, 125.3671 +4249, 66.12426, 128.6776 +4250, 67.87785, 132.3484 +4251, 66.8531, 115.879 +4252, 69.05041, 117.2786 +4253, 70.87198, 140.1922 +4254, 67.4692, 135.8756 +4255, 70.22874, 132.974 +4256, 66.93905, 117.9845 +4257, 69.928, 127.9273 +4258, 67.46962, 122.3518 +4259, 65.00765, 109.2661 +4260, 68.97698, 134.6605 +4261, 67.28864, 129.1099 +4262, 69.65152, 129.9016 +4263, 67.41038, 135.7013 +4264, 67.80162, 140.9551 +4265, 66.75484, 101.615 +4266, 67.9469, 127.0723 +4267, 65.43768, 127.1338 +4268, 68.54153, 125.4375 +4269, 66.7501, 120.7329 +4270, 66.75808, 124.1194 +4271, 67.14647, 118.2882 +4272, 64.69559, 116.7241 +4273, 69.18516, 113.5275 +4274, 66.84281, 128.2428 +4275, 66.4464, 130.5346 +4276, 69.49077, 106.2307 +4277, 68.32951, 119.3464 +4278, 68.38974, 120.9379 +4279, 69.42584, 120.7725 +4280, 64.39313, 123.2547 +4281, 66.61651, 118.437 +4282, 65.86548, 115.3497 +4283, 68.17805, 123.2437 +4284, 67.39926, 116.7036 +4285, 66.31407, 116.4127 +4286, 70.68802, 132.3031 +4287, 67.26683, 123.296 +4288, 67.1325, 117.0996 +4289, 67.61674, 132.7665 +4290, 66.91216, 122.0016 +4291, 70.58226, 146.1837 +4292, 66.47926, 132.2434 +4293, 69.5459, 146.3853 +4294, 66.60835, 119.6048 +4295, 67.34376, 137.8448 +4296, 64.77135, 124.6944 +4297, 66.46439, 128.8286 +4298, 66.64913, 119.3743 +4299, 70.56844, 123.43 +4300, 65.31528, 106.8598 +4301, 72.48479, 134.4771 +4302, 67.86837, 129.8224 +4303, 68.52634, 109.2449 +4304, 68.61738, 123.566 +4305, 66.50536, 125.5915 +4306, 70.46311, 126.8938 +4307, 64.63883, 137.3284 +4308, 64.12338, 108.9028 +4309, 69.28959, 135.4082 +4310, 66.52926, 131.7847 +4311, 69.30883, 122.2514 +4312, 68.54471, 134.4462 +4313, 67.25904, 108.6926 +4314, 67.96864, 124.3293 +4315, 65.3382, 131.6971 +4316, 68.51678, 129.4089 +4317, 68.1636, 127.5867 +4318, 64.67487, 128.3635 +4319, 66.13689, 130.3095 +4320, 68.58303, 132.5038 +4321, 68.34844, 145.901 +4322, 64.6569, 126.4447 +4323, 68.68484, 136.1093 +4324, 67.75816, 121.0123 +4325, 68.48014, 132.472 +4326, 67.7747, 126.7129 +4327, 64.7249, 115.7365 +4328, 66.6102, 118.9776 +4329, 72.2969, 145.854 +4330, 70.30878, 148.238 +4331, 66.77503, 122.7048 +4332, 66.70433, 120.42 +4333, 69.39368, 126.5408 +4334, 67.37433, 131.6976 +4335, 67.20466, 123.5504 +4336, 67.9947, 119.9449 +4337, 67.08886, 123.5117 +4338, 68.81947, 123.5561 +4339, 71.07494, 134.0842 +4340, 68.98151, 136.7907 +4341, 69.80853, 121.3415 +4342, 70.21339, 132.8196 +4343, 67.33679, 112.8553 +4344, 73.52131, 168.881 +4345, 67.45857, 131.4655 +4346, 68.65576, 121.3053 +4347, 68.77267, 126.5212 +4348, 67.03704, 125.3926 +4349, 66.86733, 114.7951 +4350, 67.01919, 134.5043 +4351, 68.52514, 133.6321 +4352, 67.69771, 121.778 +4353, 68.43487, 126.847 +4354, 67.71514, 128.0152 +4355, 70.39987, 113.918 +4356, 68.44396, 134.0367 +4357, 66.80834, 131.6397 +4358, 67.35984, 126.8163 +4359, 67.79903, 131.89 +4360, 64.83853, 115.6714 +4361, 69.57892, 126.2769 +4362, 64.85426, 102.1079 +4363, 69.318, 139.4982 +4364, 69.58868, 151.474 +4365, 66.52781, 122.1092 +4366, 67.93528, 125.7438 +4367, 66.39941, 123.1702 +4368, 68.28614, 136.4907 +4369, 68.17646, 116.4352 +4370, 65.36868, 117.4086 +4371, 67.96446, 112.4388 +4372, 69.02437, 139.9596 +4373, 68.08001, 121.2457 +4374, 67.68973, 128.3855 +4375, 67.05199, 120.0329 +4376, 65.62946, 109.3694 +4377, 64.31704, 129.4821 +4378, 69.08279, 152.901 +4379, 66.7653, 136.5692 +4380, 72.77662, 133.6427 +4381, 66.97685, 137.0715 +4382, 70.10322, 124.931 +4383, 68.92731, 131.7141 +4384, 65.24486, 119.642 +4385, 68.7959, 131.2416 +4386, 69.0613, 119.2979 +4387, 67.39122, 115.0093 +4388, 63.14333, 122.7882 +4389, 68.43035, 124.8597 +4390, 65.72614, 98.39409 +4391, 66.71343, 124.0144 +4392, 68.2317, 124.296 +4393, 67.07728, 124.0139 +4394, 68.10745, 132.0081 +4395, 67.23206, 134.8625 +4396, 69.76432, 136.0319 +4397, 66.65442, 127.9094 +4398, 67.20022, 136.8048 +4399, 71.20749, 138.9045 +4400, 71.64258, 154.3787 +4401, 68.09536, 139.4726 +4402, 68.11601, 138.099 +4403, 69.57164, 133.752 +4404, 67.897, 123.706 +4405, 68.92362, 133.4767 +4406, 68.85579, 129.4416 +4407, 66.93016, 145.6689 +4408, 71.03782, 126.1809 +4409, 66.94058, 121.4461 +4410, 69.32304, 142.2131 +4411, 67.21622, 119.7238 +4412, 64.26905, 106.7157 +4413, 67.43203, 130.1147 +4414, 68.98981, 138.5589 +4415, 67.38395, 120.821 +4416, 67.72313, 112.5397 +4417, 67.79721, 127.7983 +4418, 67.98674, 133.9054 +4419, 66.87883, 99.56439 +4420, 69.75841, 122.1663 +4421, 67.87888, 131.3067 +4422, 69.23586, 143.7584 +4423, 68.7266, 151.6764 +4424, 67.19957, 115.6396 +4425, 66.58109, 107.1456 +4426, 68.82634, 150.2899 +4427, 67.67068, 118.7544 +4428, 64.81833, 108.9651 +4429, 68.88452, 136.5556 +4430, 65.39146, 124.8106 +4431, 69.91503, 119.8377 +4432, 63.54206, 99.76986 +4433, 70.13123, 148.4142 +4434, 67.05703, 133.3179 +4435, 69.45941, 135.9285 +4436, 66.94935, 128.028 +4437, 67.81851, 122.8946 +4438, 63.65292, 127.5172 +4439, 67.11763, 127.4499 +4440, 68.64794, 136.7766 +4441, 69.3026, 132.8961 +4442, 68.60861, 122.4088 +4443, 66.80109, 113.3951 +4444, 70.87196, 115.3527 +4445, 67.90794, 136.4296 +4446, 64.88167, 131.3802 +4447, 70.78203, 151.4922 +4448, 70.35834, 112.2811 +4449, 66.99549, 129.9559 +4450, 68.83182, 116.898 +4451, 67.33693, 124.2691 +4452, 68.98465, 127.9153 +4453, 67.60913, 139.9747 +4454, 65.38645, 117.6032 +4455, 68.16769, 133.1749 +4456, 68.17351, 119.293 +4457, 69.88287, 122.8937 +4458, 67.58588, 123.5244 +4459, 68.5846, 131.1773 +4460, 67.00383, 95.88791 +4461, 69.99553, 158.3578 +4462, 72.53259, 133.576 +4463, 65.08427, 135.3471 +4464, 66.11127, 128.7408 +4465, 69.9046, 129.0113 +4466, 67.97472, 118.2064 +4467, 66.82932, 136.9731 +4468, 69.3533, 134.4424 +4469, 71.39534, 124.8929 +4470, 66.59922, 136.3075 +4471, 69.40189, 120.8579 +4472, 70.27495, 135.9954 +4473, 67.31858, 124.6169 +4474, 71.45173, 131.5614 +4475, 68.83931, 157.078 +4476, 68.99723, 124.6289 +4477, 67.73454, 132.1244 +4478, 64.8353, 118.2692 +4479, 70.74426, 139.9319 +4480, 72.26598, 149.2389 +4481, 64.72663, 126.0976 +4482, 67.5752, 119.6545 +4483, 69.51645, 140.2187 +4484, 70.48831, 111.7304 +4485, 69.32666, 128.4377 +4486, 68.52587, 109.5741 +4487, 73.16001, 135.1826 +4488, 64.28542, 119.4849 +4489, 66.65608, 135.1861 +4490, 64.71064, 111.5654 +4491, 62.99042, 115.6669 +4492, 68.70787, 123.0031 +4493, 68.12126, 126.6086 +4494, 66.77899, 122.0006 +4495, 68.23149, 119.6607 +4496, 68.42894, 122.0538 +4497, 64.0197, 127.9519 +4498, 71.09565, 117.1362 +4499, 69.87248, 147.2908 +4500, 66.51831, 125.4061 +4501, 68.57445, 123.3187 +4502, 67.46212, 139.4874 +4503, 69.61527, 137.9174 +4504, 66.86386, 119.266 +4505, 66.18998, 115.9555 +4506, 69.7905, 130.5095 +4507, 70.21174, 131.2829 +4508, 71.14846, 130.8226 +4509, 74.28376, 147.7877 +4510, 64.48835, 102.7518 +4511, 65.97201, 124.009 +4512, 66.51754, 134.4456 +4513, 67.83224, 125.095 +4514, 68.7614, 138.5499 +4515, 70.18641, 134.395 +4516, 65.12676, 118.875 +4517, 71.25743, 136.5501 +4518, 67.75602, 127.7343 +4519, 67.80062, 120.5416 +4520, 66.71286, 137.1043 +4521, 65.9331, 119.1788 +4522, 70.75201, 124.9258 +4523, 64.36337, 100.9973 +4524, 66.51439, 111.0706 +4525, 69.03382, 143.6707 +4526, 65.454, 124.8217 +4527, 68.82248, 136.6368 +4528, 69.35365, 136.1504 +4529, 68.4663, 126.8492 +4530, 69.50765, 133.1992 +4531, 67.68823, 138.961 +4532, 69.41031, 136.4148 +4533, 69.67469, 118.0784 +4534, 68.04007, 149.4074 +4535, 65.16827, 124.2854 +4536, 66.15991, 131.0075 +4537, 65.87678, 122.0955 +4538, 66.73303, 125.1468 +4539, 66.77722, 107.7781 +4540, 67.93868, 131.2999 +4541, 67.48863, 128.1304 +4542, 70.19163, 111.1449 +4543, 66.40732, 111.0917 +4544, 68.05629, 115.4242 +4545, 65.52001, 132.1594 +4546, 65.64331, 121.3271 +4547, 65.63637, 136.2254 +4548, 67.70932, 115.7406 +4549, 67.49917, 133.5066 +4550, 66.29127, 127.8453 +4551, 69.74138, 142.3054 +4552, 63.45437, 106.2611 +4553, 69.46406, 134.3778 +4554, 68.05326, 120.6881 +4555, 67.07399, 139.5754 +4556, 65.59536, 124.4232 +4557, 70.01907, 122.7936 +4558, 67.13432, 122.1132 +4559, 69.95471, 139.8142 +4560, 68.31764, 130.2584 +4561, 67.93284, 111.6216 +4562, 68.37831, 109.8238 +4563, 69.38169, 138.2864 +4564, 67.83912, 121.4831 +4565, 66.76314, 120.3041 +4566, 69.13398, 124.0916 +4567, 65.58554, 119.738 +4568, 67.12002, 132.4267 +4569, 68.20826, 126.163 +4570, 69.83352, 124.5901 +4571, 68.52243, 129.9774 +4572, 66.61883, 114.8356 +4573, 67.03413, 123.505 +4574, 68.58395, 124.7217 +4575, 68.48187, 126.5771 +4576, 68.22285, 143.9747 +4577, 70.11615, 127.6471 +4578, 64.31068, 119.6461 +4579, 68.91069, 103.7011 +4580, 68.01192, 140.6438 +4581, 68.44067, 130.1721 +4582, 69.5139, 132.2547 +4583, 69.20247, 118.3357 +4584, 66.04611, 107.3271 +4585, 66.015, 134.3205 +4586, 69.00199, 128.0736 +4587, 69.61754, 143.0774 +4588, 69.41293, 127.4879 +4589, 68.42341, 117.5081 +4590, 68.59122, 132.3095 +4591, 70.47426, 126.1309 +4592, 70.13001, 138.7704 +4593, 69.01521, 128.4133 +4594, 70.97422, 129.5877 +4595, 69.42301, 116.2255 +4596, 66.84684, 111.121 +4597, 68.37668, 118.7218 +4598, 67.80923, 131.6974 +4599, 66.4699, 141.4318 +4600, 70.23437, 138.4311 +4601, 70.16075, 139.4051 +4602, 66.23907, 109.824 +4603, 68.76154, 125.4809 +4604, 64.64843, 122.8828 +4605, 69.51686, 150.847 +4606, 67.7263, 128.1654 +4607, 68.53926, 121.0356 +4608, 68.16448, 137.2303 +4609, 70.16738, 131.504 +4610, 66.92499, 127.9481 +4611, 67.18215, 127.5982 +4612, 65.35392, 125.9641 +4613, 67.71159, 128.942 +4614, 69.35197, 123.6344 +4615, 67.54023, 132.426 +4616, 68.43556, 122.0015 +4617, 66.50187, 130.4876 +4618, 68.9358, 127.2358 +4619, 65.99168, 119.7409 +4620, 69.45486, 140.6464 +4621, 66.9045, 137.6207 +4622, 67.63969, 118.1787 +4623, 66.1437, 128.4443 +4624, 67.59159, 134.3476 +4625, 71.78019, 166.3016 +4626, 69.44107, 123.4122 +4627, 71.98935, 142.7132 +4628, 70.15393, 123.8781 +4629, 70.10971, 126.9465 +4630, 66.68738, 117.3343 +4631, 70.49701, 137.1545 +4632, 65.43499, 105.8885 +4633, 69.52902, 123.5902 +4634, 66.08382, 128.3405 +4635, 67.53462, 122.189 +4636, 66.70738, 119.1554 +4637, 67.68437, 127.9357 +4638, 64.9133, 117.8536 +4639, 66.99054, 114.2598 +4640, 66.90392, 124.3436 +4641, 68.30928, 121.873 +4642, 67.78254, 107.1698 +4643, 66.67402, 105.6942 +4644, 68.02345, 105.9209 +4645, 66.26386, 110.0377 +4646, 68.65872, 126.4691 +4647, 68.8758, 133.5623 +4648, 70.66494, 110.5288 +4649, 67.46764, 142.8422 +4650, 66.86561, 131.3179 +4651, 68.07938, 142.0148 +4652, 66.97214, 105.1855 +4653, 67.09087, 119.0616 +4654, 66.25477, 131.6159 +4655, 68.48544, 123.1869 +4656, 67.56328, 114.1342 +4657, 67.94652, 127.8594 +4658, 67.63842, 123.8136 +4659, 69.49172, 139.1029 +4660, 69.35023, 117.3644 +4661, 68.48414, 155.8502 +4662, 67.34242, 133.4692 +4663, 63.7973, 128.2173 +4664, 66.47145, 128.9056 +4665, 68.39396, 145.1997 +4666, 67.86356, 117.7852 +4667, 69.62777, 129.2314 +4668, 65.50648, 110.3151 +4669, 72.72292, 145.1721 +4670, 70.14217, 132.9902 +4671, 68.78695, 121.1068 +4672, 68.67806, 137.4109 +4673, 71.31953, 141.1587 +4674, 67.84642, 137.6199 +4675, 68.40321, 111.129 +4676, 65.63922, 129.8425 +4677, 70.43045, 130.4964 +4678, 68.00444, 124.4823 +4679, 67.39155, 138.9571 +4680, 68.0015, 136.2141 +4681, 69.24153, 131.2422 +4682, 68.36251, 106.3978 +4683, 68.48326, 124.4191 +4684, 63.36476, 110.7614 +4685, 64.47663, 125.7709 +4686, 65.29852, 114.0163 +4687, 66.60327, 135.8777 +4688, 71.58316, 133.3415 +4689, 69.32199, 138.8873 +4690, 69.28785, 132.6007 +4691, 65.72065, 123.9237 +4692, 70.17847, 127.4536 +4693, 67.75328, 148.2412 +4694, 68.02834, 122.158 +4695, 67.12107, 119.7528 +4696, 69.66713, 117.5732 +4697, 69.00275, 125.9822 +4698, 65.31244, 137.7114 +4699, 67.28896, 108.2831 +4700, 68.80003, 133.9222 +4701, 68.98651, 128.5798 +4702, 67.06068, 136.4265 +4703, 68.05695, 128.2201 +4704, 66.84523, 112.124 +4705, 68.59912, 135.1695 +4706, 67.74997, 127.2095 +4707, 67.38104, 119.7502 +4708, 69.44609, 119.5742 +4709, 66.16242, 137.4896 +4710, 68.41685, 129.0061 +4711, 71.03861, 147.6293 +4712, 66.91687, 126.9994 +4713, 68.77967, 110.6833 +4714, 69.49877, 137.0191 +4715, 65.22814, 125.0944 +4716, 66.60077, 142.9751 +4717, 69.16164, 129.2245 +4718, 67.09027, 142.6689 +4719, 67.51801, 133.2004 +4720, 63.13165, 135.8015 +4721, 73.45251, 155.9981 +4722, 63.47897, 110.1628 +4723, 67.17019, 137.8439 +4724, 66.73316, 121.0711 +4725, 67.93199, 115.9738 +4726, 70.64087, 129.3937 +4727, 65.33506, 111.071 +4728, 66.92901, 111.5159 +4729, 71.16317, 144.9723 +4730, 68.19393, 123.3543 +4731, 68.17463, 127.3197 +4732, 65.15114, 111.6275 +4733, 66.95485, 123.4444 +4734, 68.71217, 116.1338 +4735, 66.21228, 106.3145 +4736, 68.06876, 129.3926 +4737, 70.20125, 145.3962 +4738, 67.33368, 130.253 +4739, 67.63632, 144.0878 +4740, 66.23692, 122.5351 +4741, 67.59318, 133.0454 +4742, 67.82746, 107.4374 +4743, 71.17149, 149.076 +4744, 64.72317, 116.8801 +4745, 63.55844, 103.049 +4746, 69.71436, 117.5245 +4747, 68.3598, 130.8889 +4748, 68.51115, 143.0422 +4749, 66.59144, 105.2595 +4750, 68.90018, 120.1055 +4751, 68.62103, 143.016 +4752, 67.84607, 126.8695 +4753, 68.54416, 138.9043 +4754, 66.54197, 121.5207 +4755, 70.09349, 131.7383 +4756, 68.07186, 120.9546 +4757, 69.12659, 138.612 +4758, 70.69432, 147.3622 +4759, 68.92726, 130.0261 +4760, 67.10353, 124.1674 +4761, 68.07727, 143.489 +4762, 65.82037, 123.8217 +4763, 68.89326, 130.7247 +4764, 66.85902, 123.2355 +4765, 69.44484, 114.1544 +4766, 68.71047, 153.0572 +4767, 69.65196, 126.5914 +4768, 66.28558, 120.8002 +4769, 69.30112, 129.099 +4770, 70.5502, 145.7179 +4771, 67.09825, 121.1429 +4772, 66.43672, 119.0362 +4773, 68.01988, 134.8026 +4774, 65.04188, 132.806 +4775, 69.12072, 127.696 +4776, 66.70731, 131.1142 +4777, 71.77408, 129.1887 +4778, 68.2889, 114.3058 +4779, 64.9734, 114.0111 +4780, 71.4599, 141.1522 +4781, 65.03556, 113.4672 +4782, 69.05564, 136.4157 +4783, 70.76986, 134.7036 +4784, 67.74608, 129.3842 +4785, 65.393, 97.8247 +4786, 68.01276, 130.7321 +4787, 70.21576, 146.9626 +4788, 69.68073, 139.0045 +4789, 67.54382, 126.4992 +4790, 70.15526, 138.6155 +4791, 68.40203, 123.6083 +4792, 65.77722, 132.5113 +4793, 66.97553, 125.2087 +4794, 69.02762, 116.7207 +4795, 68.43486, 140.1941 +4796, 68.55513, 115.1087 +4797, 69.0732, 129.883 +4798, 68.09033, 124.4072 +4799, 69.05185, 127.8751 +4800, 66.95318, 118.9592 +4801, 69.27087, 136.2203 +4802, 64.46096, 114.2431 +4803, 64.9549, 111.1484 +4804, 66.87663, 134.4741 +4805, 68.23273, 125.8111 +4806, 69.044, 137.9178 +4807, 69.87691, 109.3782 +4808, 66.17919, 115.505 +4809, 65.71652, 120.607 +4810, 65.66691, 130.3822 +4811, 70.42201, 130.8399 +4812, 68.53986, 141.4287 +4813, 67.62274, 113.1045 +4814, 69.96111, 120.7486 +4815, 65.83646, 111.1042 +4816, 68.88975, 136.915 +4817, 66.11515, 125.3766 +4818, 68.70642, 132.7497 +4819, 65.79474, 118.1206 +4820, 68.52388, 129.7188 +4821, 70.82503, 138.2801 +4822, 69.38767, 127.8541 +4823, 64.99997, 106.3608 +4824, 67.55168, 118.5889 +4825, 67.1831, 117.5862 +4826, 68.17915, 133.4329 +4827, 69.20783, 120.0598 +4828, 69.94376, 124.5943 +4829, 64.18266, 118.6707 +4830, 68.05417, 135.4153 +4831, 66.24238, 121.9611 +4832, 69.33374, 133.7451 +4833, 67.55372, 118.1307 +4834, 67.24855, 128.5772 +4835, 66.37183, 124.8378 +4836, 66.21681, 135.8262 +4837, 68.48138, 115.2564 +4838, 65.99503, 146.0235 +4839, 68.20817, 143.0554 +4840, 64.83886, 120.4189 +4841, 69.47052, 136.1018 +4842, 70.66531, 135.2724 +4843, 65.31799, 113.9184 +4844, 73.62592, 144.2733 +4845, 65.64183, 139.218 +4846, 66.1763, 137.8042 +4847, 68.20944, 123.0101 +4848, 67.33013, 126.067 +4849, 70.70642, 148.5372 +4850, 69.27187, 110.7831 +4851, 66.49201, 120.029 +4852, 63.73844, 122.7468 +4853, 68.73929, 128.6261 +4854, 65.95611, 120.8344 +4855, 68.2791, 125.4675 +4856, 66.29813, 127.7337 +4857, 67.26906, 132.8131 +4858, 70.01685, 141.7715 +4859, 66.99124, 121.3387 +4860, 63.33461, 116.4184 +4861, 66.48133, 114.4604 +4862, 66.96424, 126.3607 +4863, 67.76229, 129.6594 +4864, 68.64237, 128.845 +4865, 70.16208, 141.6777 +4866, 70.96379, 140.0763 +4867, 69.50635, 126.771 +4868, 63.75673, 104.9152 +4869, 67.97424, 152.1104 +4870, 66.1089, 119.3998 +4871, 63.30114, 102.7788 +4872, 68.76435, 104.4743 +4873, 67.68224, 122.9173 +4874, 71.11972, 130.0384 +4875, 68.865, 121.9668 +4876, 70.02623, 131.5675 +4877, 65.6918, 107.2827 +4878, 63.3557, 117.6886 +4879, 66.86873, 143.4791 +4880, 63.65356, 102.6027 +4881, 65.50331, 116.8988 +4882, 68.61979, 123.9844 +4883, 71.06865, 136.2899 +4884, 67.90434, 123.2082 +4885, 69.04428, 144.3998 +4886, 68.23808, 145.3389 +4887, 67.60055, 119.9359 +4888, 68.72349, 131.6298 +4889, 69.72755, 133.7225 +4890, 67.39229, 146.2703 +4891, 67.19624, 119.8227 +4892, 65.56913, 107.9515 +4893, 65.93896, 109.1714 +4894, 68.3392, 134.1385 +4895, 66.37854, 130.6212 +4896, 68.06195, 116.0239 +4897, 72.14804, 134.4365 +4898, 66.3, 134.8203 +4899, 70.52384, 116.5449 +4900, 65.956, 126.3619 +4901, 69.77937, 127.6585 +4902, 68.01271, 125.5257 +4903, 71.04627, 134.624 +4904, 70.30748, 129.3855 +4905, 69.8685, 127.9899 +4906, 68.55351, 119.5254 +4907, 68.04279, 111.4427 +4908, 68.32377, 143.6406 +4909, 68.43992, 124.9 +4910, 69.70106, 125.39 +4911, 69.86274, 126.7733 +4912, 65.28588, 120.2017 +4913, 68.23316, 120.3497 +4914, 67.56772, 130.5236 +4915, 67.92319, 137.9222 +4916, 65.9763, 118.559 +4917, 66.72703, 126.2936 +4918, 67.16036, 135.8841 +4919, 67.7804, 122.1423 +4920, 64.55365, 106.3292 +4921, 67.47804, 131.5261 +4922, 67.29005, 122.7303 +4923, 66.84522, 114.8025 +4924, 63.83743, 120.2347 +4925, 64.04876, 122.1794 +4926, 69.05705, 145.6834 +4927, 66.07726, 117.709 +4928, 69.83849, 131.9638 +4929, 70.33978, 128.3473 +4930, 67.88517, 132.8351 +4931, 66.30635, 120.4227 +4932, 70.70419, 127.4847 +4933, 64.63844, 111.2536 +4934, 67.37468, 118.4249 +4935, 67.32338, 132.2462 +4936, 68.79557, 137.0621 +4937, 69.49827, 130.716 +4938, 69.18297, 133.2681 +4939, 68.05335, 120.2172 +4940, 65.60027, 124.9529 +4941, 69.84728, 135.0017 +4942, 71.20265, 155.3163 +4943, 66.1002, 114.3986 +4944, 68.91567, 143.1158 +4945, 65.88189, 111.2503 +4946, 67.45521, 121.8782 +4947, 67.21505, 122.1602 +4948, 65.97609, 124.7486 +4949, 67.96746, 130.7902 +4950, 66.85926, 128.0209 +4951, 67.62991, 120.2907 +4952, 67.1994, 125.7923 +4953, 65.68971, 131.2235 +4954, 68.65173, 131.3886 +4955, 68.37333, 126.8527 +4956, 66.48906, 112.4772 +4957, 66.03608, 126.3124 +4958, 67.01056, 118.5625 +4959, 67.52148, 141.824 +4960, 68.94504, 135.164 +4961, 65.95216, 138.0343 +4962, 68.70893, 111.9057 +4963, 64.0908, 109.4352 +4964, 66.00548, 106.1651 +4965, 70.50014, 138.7377 +4966, 69.06617, 138.8835 +4967, 67.20849, 131.6754 +4968, 68.71365, 133.501 +4969, 70.4988, 123.6003 +4970, 70.09293, 120.5015 +4971, 67.10959, 127.9008 +4972, 67.94613, 108.2182 +4973, 69.9019, 132.8392 +4974, 68.45258, 112.1406 +4975, 69.5192, 131.5346 +4976, 65.52153, 124.897 +4977, 67.62906, 115.9246 +4978, 69.24378, 138.2668 +4979, 68.39542, 131.5288 +4980, 64.77157, 110.1024 +4981, 70.23436, 137.102 +4982, 65.18062, 109.788 +4983, 66.20453, 112.9286 +4984, 70.60819, 148.2754 +4985, 65.64079, 119.3393 +4986, 69.72804, 141.9129 +4987, 67.49767, 139.6238 +4988, 69.18779, 119.7962 +4989, 66.83553, 115.7201 +4990, 67.17618, 121.334 +4991, 68.75179, 159.3608 +4992, 66.51066, 133.2151 +4993, 67.34769, 141.3034 +4994, 71.80087, 129.831 +4995, 67.69782, 120.7103 +4996, 69.0048, 141.5982 +4997, 69.06523, 125.8677 +4998, 65.88747, 112.3178 +4999, 65.84895, 118.9697 +5000, 67.18311, 112.7574 +5001, 63.79598, 111.7201 +5002, 67.47173, 110.5494 +5003, 67.15867, 103.8433 +5004, 70.38311, 159.9758 +5005, 66.68444, 130.2472 +5006, 66.66715, 123.7624 +5007, 66.82297, 125.297 +5008, 66.6039, 122.711 +5009, 70.88882, 160.0364 +5010, 70.28146, 131.6777 +5011, 68.61527, 124.199 +5012, 68.94252, 122.5949 +5013, 70.00817, 143.777 +5014, 63.92219, 106.1497 +5015, 68.18982, 135.6658 +5016, 66.93297, 112.8116 +5017, 67.12819, 118.7819 +5018, 67.29436, 119.1211 +5019, 70.49073, 121.0715 +5020, 66.8532, 113.7029 +5021, 68.51902, 116.3811 +5022, 68.68968, 128.0095 +5023, 67.64082, 116.0115 +5024, 68.69251, 133.2729 +5025, 67.6248, 127.7888 +5026, 68.8846, 123.8782 +5027, 69.76061, 139.5499 +5028, 67.56118, 126.6252 +5029, 69.78513, 141.3982 +5030, 70.21612, 151.0506 +5031, 66.27644, 126.0282 +5032, 67.40846, 148.4483 +5033, 68.20932, 129.2407 +5034, 65.79974, 132.286 +5035, 64.49618, 106.4894 +5036, 65.69093, 125.0984 +5037, 68.48055, 130.2433 +5038, 66.17897, 123.5842 +5039, 63.55273, 101.2994 +5040, 67.68025, 118.3701 +5041, 65.4426, 109.8414 +5042, 67.53819, 131.1827 +5043, 67.20388, 125.2316 +5044, 65.10901, 131.8946 +5045, 67.71775, 116.0773 +5046, 66.27965, 98.28455 +5047, 71.03656, 127.6602 +5048, 69.39922, 134.0168 +5049, 67.60067, 123.7417 +5050, 69.41439, 125.4915 +5051, 67.06842, 135.2419 +5052, 68.06961, 122.0361 +5053, 63.88211, 117.4632 +5054, 65.9194, 120.1212 +5055, 70.23642, 124.4872 +5056, 63.84676, 116.313 +5057, 68.9074, 121.8405 +5058, 64.0135, 126.9209 +5059, 67.36541, 111.5266 +5060, 69.06481, 132.1843 +5061, 67.06091, 131.9966 +5062, 68.71498, 118.7562 +5063, 70.10334, 138.9367 +5064, 70.90589, 132.6605 +5065, 66.77943, 117.0903 +5066, 69.55338, 121.8668 +5067, 68.45538, 128.6212 +5068, 68.10538, 130.0686 +5069, 64.46289, 109.0084 +5070, 67.78582, 110.3563 +5071, 65.82491, 126.3494 +5072, 66.22711, 130.879 +5073, 65.4258, 130.8643 +5074, 69.33268, 123.4765 +5075, 65.30644, 111.1681 +5076, 70.66767, 151.1334 +5077, 67.86539, 127.2278 +5078, 65.68213, 114.755 +5079, 66.27532, 131.1304 +5080, 64.15129, 117.3512 +5081, 68.93691, 126.7825 +5082, 66.77623, 130.4524 +5083, 68.66098, 110.209 +5084, 66.03851, 120.0319 +5085, 71.34562, 131.9006 +5086, 66.26107, 118.9925 +5087, 70.96703, 136.5441 +5088, 65.92505, 114.2363 +5089, 66.47783, 119.0131 +5090, 68.65041, 144.86 +5091, 68.22052, 130.8069 +5092, 69.53697, 144.8661 +5093, 71.31389, 130.7968 +5094, 68.65623, 138.8268 +5095, 63.90685, 130.0556 +5096, 69.54723, 124.231 +5097, 63.83536, 119.8695 +5098, 69.43228, 110.2776 +5099, 68.8923, 127.6997 +5100, 65.97989, 142.5486 +5101, 73.25816, 157.0989 +5102, 65.69314, 138.5876 +5103, 69.95721, 128.1607 +5104, 69.93565, 130.3446 +5105, 67.55601, 119.1028 +5106, 67.47638, 115.6698 +5107, 69.05674, 128.3985 +5108, 68.54497, 136.1737 +5109, 70.44462, 116.6906 +5110, 67.11656, 131.4909 +5111, 67.60673, 115.494 +5112, 67.76797, 116.0487 +5113, 64.22799, 116.596 +5114, 67.64933, 138.6958 +5115, 66.94828, 126.0413 +5116, 68.83697, 145.686 +5117, 69.03861, 128.7906 +5118, 67.88536, 142.1595 +5119, 69.15298, 138.9115 +5120, 65.76655, 122.0769 +5121, 66.41848, 119.0393 +5122, 69.98636, 136.7085 +5123, 69.33663, 124.8379 +5124, 68.14856, 129.218 +5125, 69.61056, 124.5365 +5126, 70.24424, 132.7187 +5127, 64.66037, 110.1455 +5128, 67.14089, 132.4193 +5129, 66.55536, 120.6308 +5130, 67.02821, 134.6226 +5131, 66.61015, 131.3866 +5132, 67.87365, 134.9717 +5133, 68.48489, 121.162 +5134, 71.46727, 146.1977 +5135, 67.52509, 130.7501 +5136, 69.14416, 123.9601 +5137, 66.34347, 105.9251 +5138, 68.8517, 147.2738 +5139, 66.59398, 128.4305 +5140, 68.79421, 116.2545 +5141, 65.60404, 128.8795 +5142, 69.60759, 124.4609 +5143, 71.79002, 131.1114 +5144, 65.39644, 133.017 +5145, 68.186, 123.0559 +5146, 70.64194, 128.8506 +5147, 69.27806, 146.6325 +5148, 65.41192, 125.2607 +5149, 69.74131, 135.9477 +5150, 69.68791, 149.0918 +5151, 67.61616, 129.9896 +5152, 65.33279, 115.5896 +5153, 68.09827, 122.5938 +5154, 67.78589, 130.5478 +5155, 66.37325, 110.4683 +5156, 70.70383, 147.9488 +5157, 67.77536, 135.435 +5158, 70.16781, 132.2276 +5159, 65.08294, 124.8522 +5160, 68.09864, 139.5397 +5161, 69.72378, 127.9841 +5162, 66.10587, 129.5105 +5163, 68.81614, 128.4016 +5164, 66.34879, 136.5927 +5165, 68.85181, 131.0471 +5166, 67.88949, 135.8495 +5167, 67.3565, 124.7415 +5168, 67.87392, 123.9916 +5169, 67.82355, 120.0348 +5170, 68.93013, 119.6138 +5171, 66.72655, 104.4695 +5172, 69.96413, 141.4657 +5173, 70.92472, 133.859 +5174, 68.15966, 130.2032 +5175, 65.71158, 120.7602 +5176, 66.88241, 116.1838 +5177, 67.87445, 129.3543 +5178, 69.77941, 140.2507 +5179, 65.39579, 114.7891 +5180, 70.51058, 117.7705 +5181, 66.56644, 121.7629 +5182, 68.74163, 146.386 +5183, 68.50865, 142.5118 +5184, 67.86683, 136.538 +5185, 65.68959, 108.1989 +5186, 68.1756, 126.6541 +5187, 67.27204, 128.769 +5188, 65.3007, 130.2829 +5189, 68.37952, 126.2574 +5190, 70.39798, 119.4655 +5191, 65.3603, 112.0012 +5192, 68.8706, 129.9499 +5193, 66.21022, 116.362 +5194, 68.94788, 142.8095 +5195, 68.04951, 123.9961 +5196, 66.09906, 118.4749 +5197, 65.89673, 138.4134 +5198, 67.19993, 111.4001 +5199, 69.40899, 105.0894 +5200, 69.07487, 129.1519 +5201, 67.65384, 120.3397 +5202, 68.48956, 120.7475 +5203, 68.34723, 124.124 +5204, 69.67407, 140.3264 +5205, 65.19464, 119.1674 +5206, 69.81691, 139.3101 +5207, 64.26605, 115.7719 +5208, 68.77984, 128.1583 +5209, 64.94194, 119.9868 +5210, 69.40853, 136.2726 +5211, 66.60982, 120.7165 +5212, 68.74031, 143.4148 +5213, 72.8443, 146.7131 +5214, 65.56742, 114.1088 +5215, 67.30672, 119.2437 +5216, 67.87438, 129.1951 +5217, 67.37272, 110.0987 +5218, 68.52976, 132.8156 +5219, 67.2006, 120.7292 +5220, 71.326, 133.6295 +5221, 66.99797, 113.5302 +5222, 70.15071, 144.6167 +5223, 67.56198, 111.4511 +5224, 67.84632, 131.1354 +5225, 67.99597, 124.7397 +5226, 71.45949, 136.4103 +5227, 65.98938, 133.9456 +5228, 70.30094, 148.0703 +5229, 69.63548, 118.8671 +5230, 68.12716, 130.0225 +5231, 67.19533, 117.8517 +5232, 69.96297, 131.029 +5233, 70.75433, 139.7372 +5234, 64.90027, 99.29265 +5235, 67.53863, 122.6701 +5236, 66.93918, 112.5864 +5237, 66.74599, 114.6931 +5238, 67.53267, 124.3523 +5239, 67.03579, 113.4992 +5240, 66.19745, 119.4549 +5241, 66.16514, 116.2537 +5242, 70.4784, 141.2563 +5243, 66.71437, 112.926 +5244, 67.52916, 120.8297 +5245, 70.87923, 144.9908 +5246, 70.87713, 120.3404 +5247, 62.52373, 101.0402 +5248, 67.78636, 136.2587 +5249, 67.1394, 121.6793 +5250, 67.39241, 124.8535 +5251, 65.87821, 127.8471 +5252, 66.55073, 137.5442 +5253, 65.77153, 103.9089 +5254, 67.98557, 141.2212 +5255, 66.84341, 115.4613 +5256, 69.21199, 128.5016 +5257, 66.35945, 122.8733 +5258, 69.23369, 130.3051 +5259, 68.82616, 133.9048 +5260, 69.36336, 139.0361 +5261, 70.20959, 134.7929 +5262, 68.15011, 136.8965 +5263, 68.06755, 112.9757 +5264, 66.61783, 113.0753 +5265, 66.84021, 131.2762 +5266, 70.60805, 145.9398 +5267, 70.98349, 143.2473 +5268, 68.09578, 136.2662 +5269, 68.63828, 134.4078 +5270, 69.50947, 135.2759 +5271, 67.27908, 118.9625 +5272, 67.62248, 106.5357 +5273, 65.98498, 124.1788 +5274, 70.60025, 143.1552 +5275, 65.18921, 118.4354 +5276, 66.32422, 120.6698 +5277, 67.62091, 136.1237 +5278, 69.19727, 113.7928 +5279, 66.1129, 124.6016 +5280, 68.12418, 133.7479 +5281, 69.48945, 143.7332 +5282, 67.16699, 122.6097 +5283, 66.45846, 127.9224 +5284, 68.57463, 119.9155 +5285, 70.02842, 158.2521 +5286, 65.46377, 101.8393 +5287, 66.48352, 125.5619 +5288, 65.78847, 112.7934 +5289, 69.14324, 113.9947 +5290, 66.10192, 120.5016 +5291, 68.5156, 110.4182 +5292, 64.2164, 129.756 +5293, 69.15358, 129.065 +5294, 66.83911, 126.2087 +5295, 64.05746, 109.798 +5296, 67.80361, 134.8236 +5297, 67.78006, 146.6249 +5298, 66.0792, 121.5591 +5299, 67.54866, 119.1681 +5300, 67.18499, 111.7433 +5301, 66.36282, 123.4684 +5302, 66.21209, 120.9058 +5303, 69.61635, 123.0992 +5304, 66.83693, 123.2452 +5305, 71.80311, 132.7094 +5306, 67.0625, 126.7332 +5307, 72.96339, 135.2564 +5308, 70.34828, 151.3674 +5309, 70.09653, 150.9294 +5310, 69.20104, 140.2394 +5311, 70.35624, 132.7655 +5312, 69.78453, 144.8798 +5313, 71.39937, 129.2934 +5314, 67.0059, 116.8217 +5315, 66.79299, 124.906 +5316, 67.86676, 125.3757 +5317, 67.25419, 103.8437 +5318, 68.56236, 122.4352 +5319, 66.43275, 136.132 +5320, 68.91151, 125.792 +5321, 67.50477, 126.8799 +5322, 69.08511, 145.0689 +5323, 68.7803, 148.623 +5324, 66.66053, 135.6636 +5325, 68.66602, 114.7145 +5326, 68.47595, 114.8512 +5327, 67.53608, 128.0852 +5328, 66.23142, 121.6196 +5329, 69.17542, 124.7148 +5330, 67.34508, 120.9551 +5331, 67.77776, 117.0167 +5332, 66.91716, 115.5379 +5333, 68.65138, 130.497 +5334, 66.97762, 136.012 +5335, 69.11727, 140.2511 +5336, 65.2278, 132.8841 +5337, 66.3529, 126.9573 +5338, 67.90441, 122.0685 +5339, 67.14182, 107.8829 +5340, 69.26936, 139.1728 +5341, 67.55353, 123.1504 +5342, 69.1191, 127.1047 +5343, 66.5787, 130.5048 +5344, 68.34422, 126.8956 +5345, 70.87732, 142.4991 +5346, 66.25515, 109.9755 +5347, 70.20374, 142.2116 +5348, 65.37244, 119.6729 +5349, 69.21393, 139.5979 +5350, 66.65743, 125.0117 +5351, 70.90598, 144.8867 +5352, 67.63273, 116.9137 +5353, 67.44579, 133.6929 +5354, 69.61543, 149.4255 +5355, 70.72786, 134.2975 +5356, 67.81233, 134.3642 +5357, 68.88371, 130.2664 +5358, 67.59685, 128.0565 +5359, 66.18908, 129.8912 +5360, 67.0619, 122.516 +5361, 71.40566, 142.8255 +5362, 69.94381, 144.2052 +5363, 68.12088, 129.3957 +5364, 70.07833, 132.5733 +5365, 69.21921, 138.4788 +5366, 65.07625, 120.4977 +5367, 66.64317, 86.982 +5368, 69.09678, 136.2561 +5369, 67.29797, 128.014 +5370, 70.07962, 138.1994 +5371, 68.17719, 128.9954 +5372, 70.62613, 147.3147 +5373, 72.75675, 155.6063 +5374, 65.50945, 114.2107 +5375, 69.80503, 118.0632 +5376, 68.48037, 122.2135 +5377, 69.39191, 132.1548 +5378, 69.89743, 132.8384 +5379, 71.03366, 120.7296 +5380, 64.18042, 105.3415 +5381, 67.25981, 115.6019 +5382, 69.88668, 133.1821 +5383, 68.77416, 143.2226 +5384, 70.75119, 132.8196 +5385, 69.77175, 140.4321 +5386, 66.47653, 135.1056 +5387, 68.16365, 127.6326 +5388, 66.4353, 134.5752 +5389, 70.13482, 122.9368 +5390, 71.70658, 136.632 +5391, 66.92527, 123.4431 +5392, 67.12563, 123.5752 +5393, 69.16564, 125.887 +5394, 68.8406, 125.7733 +5395, 70.75604, 166.2812 +5396, 71.42444, 131.7763 +5397, 69.45553, 134.4084 +5398, 67.59746, 131.5971 +5399, 69.20977, 129.3553 +5400, 68.55325, 132.7205 +5401, 68.57877, 120.9452 +5402, 66.26275, 100.455 +5403, 65.96056, 113.3895 +5404, 69.5447, 134.9309 +5405, 69.03723, 121.8168 +5406, 70.25581, 149.6514 +5407, 65.24262, 118.8877 +5408, 66.61174, 123.9036 +5409, 65.44916, 129.4155 +5410, 68.46313, 115.2733 +5411, 70.08288, 130.4398 +5412, 68.28223, 134.7568 +5413, 67.00556, 125.5138 +5414, 66.02293, 109.5969 +5415, 69.16478, 135.6481 +5416, 67.21577, 131.9731 +5417, 69.00086, 135.9877 +5418, 70.75525, 135.7754 +5419, 69.25232, 127.8223 +5420, 67.57183, 119.3432 +5421, 67.67452, 132.6705 +5422, 67.40515, 124.2707 +5423, 64.86031, 100.9173 +5424, 69.39033, 112.2069 +5425, 65.9698, 129.9153 +5426, 67.55171, 123.0908 +5427, 68.46426, 116.498 +5428, 66.23821, 104.1053 +5429, 70.6257, 119.2626 +5430, 66.61423, 116.9318 +5431, 70.66932, 148.9742 +5432, 67.57132, 119.5476 +5433, 69.45353, 117.3488 +5434, 66.26159, 125.5437 +5435, 68.73293, 124.2368 +5436, 68.82534, 133.8431 +5437, 70.13099, 131.2805 +5438, 71.82375, 146.9215 +5439, 65.90074, 103.4218 +5440, 63.727, 120.0775 +5441, 66.99543, 121.7611 +5442, 67.3499, 132.3056 +5443, 67.16004, 112.2736 +5444, 70.5283, 128.9156 +5445, 68.45206, 121.7201 +5446, 66.09346, 105.8554 +5447, 64.7808, 125.8367 +5448, 68.29845, 132.8929 +5449, 66.31173, 125.5959 +5450, 64.36944, 122.6652 +5451, 69.23895, 132.3741 +5452, 70.56453, 122.723 +5453, 63.44115, 93.29146 +5454, 67.49847, 113.1057 +5455, 69.85577, 118.0316 +5456, 69.07982, 130.5538 +5457, 69.56211, 137.4123 +5458, 68.17484, 142.9581 +5459, 70.23972, 137.4064 +5460, 70.6554, 143.3564 +5461, 66.4574, 122.5937 +5462, 64.31855, 119.3805 +5463, 65.49751, 110.3743 +5464, 69.47428, 139.4867 +5465, 67.88158, 125.4501 +5466, 69.53913, 124.3466 +5467, 63.83987, 92.65767 +5468, 69.07601, 123.9516 +5469, 69.47709, 126.9161 +5470, 67.08504, 121.9957 +5471, 70.95488, 139.7854 +5472, 68.64084, 123.2444 +5473, 65.86462, 113.0349 +5474, 67.72662, 119.5902 +5475, 65.32212, 102.5086 +5476, 69.00392, 128.9232 +5477, 69.63523, 132.2697 +5478, 66.71665, 128.5803 +5479, 69.5893, 127.2246 +5480, 68.66987, 120.1516 +5481, 67.85418, 113.5575 +5482, 68.78852, 120.1342 +5483, 68.2002, 134.9707 +5484, 63.0824, 109.7702 +5485, 67.2833, 122.8477 +5486, 71.21834, 131.494 +5487, 71.01583, 138.9013 +5488, 69.88229, 143.1039 +5489, 67.19375, 121.1828 +5490, 68.76347, 130.2964 +5491, 66.83011, 120.5375 +5492, 70.56089, 132.0461 +5493, 69.67899, 140.8938 +5494, 66.96319, 122.3291 +5495, 68.67573, 115.6268 +5496, 66.39372, 121.1097 +5497, 69.81996, 125.3109 +5498, 68.00995, 124.8272 +5499, 66.95032, 118.4744 +5500, 70.96239, 144.0736 +5501, 66.27024, 126.7344 +5502, 68.21726, 115.0624 +5503, 66.56206, 112.4637 +5504, 69.03964, 137.6269 +5505, 68.68271, 131.7407 +5506, 68.91258, 115.3276 +5507, 68.02805, 123.1233 +5508, 68.64452, 111.4743 +5509, 67.98404, 120.7929 +5510, 65.72168, 123.0248 +5511, 68.50899, 125.2258 +5512, 68.74484, 118.5521 +5513, 65.70055, 121.1912 +5514, 68.13231, 126.9522 +5515, 69.1712, 102.8732 +5516, 70.67886, 122.3412 +5517, 68.837, 118.7874 +5518, 69.60496, 130.4536 +5519, 67.41523, 126.8208 +5520, 71.4, 154.97 +5521, 69.57502, 130.0883 +5522, 69.04149, 116.7796 +5523, 68.5837, 143.8448 +5524, 66.89024, 126.5347 +5525, 67.12473, 111.1866 +5526, 67.83542, 111.946 +5527, 70.46759, 138.7422 +5528, 67.7864, 142.7435 +5529, 69.58276, 143.2414 +5530, 67.16684, 125.1273 +5531, 67.13791, 108.6479 +5532, 68.79915, 132.8302 +5533, 67.64203, 127.7226 +5534, 64.70508, 111.3172 +5535, 68.08348, 133.8261 +5536, 67.56671, 124.2366 +5537, 64.28754, 102.4825 +5538, 64.85395, 111.9585 +5539, 73.24733, 138.1346 +5540, 64.89302, 114.3071 +5541, 67.43272, 133.0682 +5542, 65.7765, 118.0115 +5543, 70.7064, 145.9957 +5544, 67.52445, 125.9386 +5545, 67.01528, 116.8078 +5546, 68.16565, 113.8239 +5547, 67.99779, 149.3131 +5548, 68.52996, 110.5189 +5549, 67.53327, 120.1058 +5550, 67.30047, 123.1704 +5551, 67.63847, 134.5804 +5552, 68.52047, 138.8459 +5553, 68.03264, 127.8527 +5554, 67.28722, 118.5444 +5555, 68.42927, 127.9474 +5556, 69.7329, 125.5398 +5557, 69.72725, 127.1998 +5558, 69.73079, 152.3984 +5559, 69.97947, 137.3347 +5560, 68.9122, 119.5773 +5561, 66.70355, 122.2617 +5562, 68.64652, 136.3536 +5563, 67.56584, 136.2134 +5564, 67.35146, 123.6386 +5565, 66.98205, 107.619 +5566, 65.44633, 135.5837 +5567, 68.81325, 129.6697 +5568, 67.16659, 107.8736 +5569, 70.28813, 150.9046 +5570, 66.62449, 139.4685 +5571, 64.39542, 115.1983 +5572, 67.23695, 112.4262 +5573, 69.67397, 156.7309 +5574, 68.43681, 127.8894 +5575, 68.00999, 131.2092 +5576, 70.8081, 135.2499 +5577, 70.50871, 122.7718 +5578, 70.00808, 117.6198 +5579, 66.06797, 101.461 +5580, 67.87768, 116.3499 +5581, 69.36261, 126.9441 +5582, 69.29301, 139.7644 +5583, 67.3539, 133.1416 +5584, 66.1525, 110.9469 +5585, 67.47153, 115.3734 +5586, 68.56556, 121.8413 +5587, 72.40237, 157.4235 +5588, 67.28205, 128.5724 +5589, 65.7493, 122.6496 +5590, 65.90868, 132.421 +5591, 67.32651, 133.7645 +5592, 67.04617, 112.1093 +5593, 67.21086, 122.6801 +5594, 66.49245, 109.2367 +5595, 69.2678, 122.5007 +5596, 70.07489, 149.6391 +5597, 69.74977, 141.1522 +5598, 66.75226, 139.719 +5599, 65.50834, 114.5278 +5600, 73.13491, 127.8612 +5601, 65.37072, 125.7601 +5602, 72.07311, 142.2552 +5603, 67.65702, 120.8003 +5604, 71.13971, 149.4626 +5605, 69.56951, 138.5706 +5606, 68.47465, 116.2406 +5607, 68.65104, 135.3612 +5608, 69.29567, 146.4768 +5609, 65.94966, 131.8327 +5610, 67.88775, 137.3897 +5611, 66.01091, 107.5225 +5612, 64.69531, 124.1449 +5613, 68.76234, 111.5343 +5614, 70.14278, 129.6087 +5615, 65.29027, 126.534 +5616, 67.02973, 130.5432 +5617, 72.18645, 153.9204 +5618, 68.32435, 130.9603 +5619, 65.37779, 114.4 +5620, 70.98789, 126.8208 +5621, 69.32981, 125.881 +5622, 68.08517, 125.3363 +5623, 67.72864, 117.6713 +5624, 69.41996, 126.183 +5625, 65.86211, 112.0669 +5626, 69.96526, 151.6467 +5627, 67.91088, 124.1618 +5628, 68.78786, 130.6754 +5629, 65.74585, 119.2501 +5630, 72.368, 132.7354 +5631, 68.18716, 129.4416 +5632, 69.84822, 130.4897 +5633, 68.77683, 132.0897 +5634, 69.84154, 117.5002 +5635, 68.21258, 108.6233 +5636, 66.95108, 127.1378 +5637, 66.85975, 122.3951 +5638, 66.15618, 118.9815 +5639, 67.45204, 125.2554 +5640, 67.60013, 121.8996 +5641, 66.75233, 120.7738 +5642, 60.8634, 106.1939 +5643, 66.19796, 107.8874 +5644, 65.67776, 122.0686 +5645, 68.99828, 117.3948 +5646, 68.02827, 140.866 +5647, 70.31743, 149.3078 +5648, 64.89375, 125.5845 +5649, 65.54201, 131.28 +5650, 68.67927, 120.8432 +5651, 66.50307, 123.0181 +5652, 67.06639, 143.1561 +5653, 68.34809, 122.9334 +5654, 67.7237, 118.4002 +5655, 71.2729, 133.799 +5656, 66.02325, 115.9951 +5657, 67.64412, 117.6164 +5658, 70.5122, 133.0952 +5659, 65.81299, 111.2517 +5660, 67.72994, 134.9223 +5661, 70.37065, 142.7071 +5662, 67.12868, 128.8292 +5663, 67.7056, 126.9298 +5664, 67.17205, 115.2964 +5665, 68.10555, 136.4014 +5666, 70.02968, 139.6796 +5667, 67.74365, 132.6488 +5668, 64.0239, 131.5816 +5669, 65.72062, 109.6616 +5670, 72.30502, 138.1492 +5671, 68.49538, 132.5811 +5672, 68.88875, 126.3917 +5673, 66.99923, 133.9106 +5674, 68.12136, 137.1759 +5675, 69.35409, 135.8339 +5676, 65.94423, 130.5612 +5677, 69.1535, 134.0018 +5678, 68.9858, 133.0763 +5679, 66.5432, 109.9605 +5680, 67.00921, 132.5041 +5681, 71.09758, 126.9142 +5682, 68.07213, 124.4069 +5683, 69.49666, 146.5182 +5684, 70.21782, 140.9199 +5685, 67.58857, 133.1095 +5686, 67.57075, 138.0985 +5687, 69.42517, 137.6923 +5688, 68.28537, 136.6422 +5689, 69.72848, 149.467 +5690, 69.92365, 138.0429 +5691, 68.79953, 113.512 +5692, 69.09202, 130.8401 +5693, 68.82166, 125.858 +5694, 68.79217, 113.7784 +5695, 68.20921, 118.9215 +5696, 64.85301, 114.4354 +5697, 68.43265, 123.9837 +5698, 68.41712, 135.6646 +5699, 68.48985, 97.85054 +5700, 67.77927, 130.3916 +5701, 66.72234, 138.3614 +5702, 66.17694, 125.4018 +5703, 68.07653, 118.6076 +5704, 68.39248, 109.8622 +5705, 66.36527, 120.0788 +5706, 62.87732, 86.669 +5707, 68.7832, 142.6252 +5708, 70.32779, 135.5365 +5709, 65.23714, 130.1058 +5710, 70.09673, 141.5957 +5711, 72.58203, 125.2756 +5712, 68.95451, 131.6178 +5713, 70.08286, 129.0769 +5714, 66.60565, 108.4805 +5715, 70.12381, 139.1288 +5716, 68.9783, 145.3523 +5717, 65.41373, 125.9004 +5718, 70.84046, 126.4751 +5719, 65.25996, 119.209 +5720, 67.59199, 123.0037 +5721, 69.34865, 129.4727 +5722, 69.39296, 141.9344 +5723, 63.75403, 108.9765 +5724, 67.96208, 118.2419 +5725, 70.15448, 141.4635 +5726, 70.04724, 136.5986 +5727, 66.06389, 105.223 +5728, 71.07997, 127.8639 +5729, 66.6113, 134.331 +5730, 66.86237, 140.5931 +5731, 70.25969, 127.8158 +5732, 65.89945, 110.9553 +5733, 68.29227, 112.17 +5734, 64.95871, 117.7368 +5735, 67.1086, 133.5058 +5736, 67.39014, 119.9727 +5737, 64.25871, 115.9128 +5738, 69.27316, 131.0059 +5739, 67.87387, 121.2352 +5740, 65.53554, 121.5301 +5741, 71.08776, 130.4852 +5742, 67.36554, 127.386 +5743, 65.41184, 115.7506 +5744, 68.03292, 127.3987 +5745, 66.72356, 134.9064 +5746, 68.02466, 131.4015 +5747, 67.36662, 117.1467 +5748, 68.93518, 116.5689 +5749, 68.578, 127.307 +5750, 64.74187, 115.184 +5751, 66.2743, 114.0988 +5752, 69.71458, 131.5924 +5753, 68.54427, 137.3566 +5754, 71.35055, 135.1059 +5755, 67.21472, 137.3314 +5756, 65.09449, 113.229 +5757, 67.50111, 111.4446 +5758, 70.80356, 138.282 +5759, 66.74779, 126.8547 +5760, 67.30525, 135.6227 +5761, 69.16712, 128.8532 +5762, 69.35292, 139.9225 +5763, 64.91373, 101.2648 +5764, 67.68617, 132.6457 +5765, 69.23168, 133.9763 +5766, 67.53083, 138.6939 +5767, 73.47519, 156.5556 +5768, 68.0664, 128.1673 +5769, 65.82069, 125.261 +5770, 69.01169, 132.9188 +5771, 69.72285, 134.5923 +5772, 70.52947, 114.1222 +5773, 67.2635, 114.8907 +5774, 69.0027, 132.8863 +5775, 67.91407, 133.1336 +5776, 66.94962, 137.487 +5777, 68.04101, 118.2847 +5778, 71.93262, 133.1505 +5779, 68.266, 127.4658 +5780, 67.22047, 133.3136 +5781, 70.82076, 151.6654 +5782, 67.97316, 131.4318 +5783, 67.86163, 116.9394 +5784, 66.75865, 130.2682 +5785, 68.68619, 122.1336 +5786, 68.55174, 118.5602 +5787, 70.64074, 136.0448 +5788, 64.54667, 101.3587 +5789, 70.20971, 139.6653 +5790, 65.24926, 122.592 +5791, 70.56077, 142.8022 +5792, 70.2161, 119.6591 +5793, 69.26794, 130.0904 +5794, 68.71495, 142.531 +5795, 69.83226, 150.4973 +5796, 67.95044, 125.4476 +5797, 66.69106, 132.6528 +5798, 66.69388, 109.0486 +5799, 68.85787, 108.4688 +5800, 66.75904, 113.7091 +5801, 69.47691, 125.2285 +5802, 69.16535, 135.7451 +5803, 66.17003, 125.3914 +5804, 65.52416, 120.5974 +5805, 65.51245, 124.223 +5806, 67.09453, 131.6406 +5807, 70.25624, 130.8484 +5808, 66.23165, 123.4666 +5809, 68.47727, 125.3201 +5810, 69.71255, 135.4164 +5811, 67.91161, 135.2628 +5812, 66.40266, 127.9538 +5813, 67.8244, 117.6057 +5814, 66.18945, 120.9807 +5815, 67.43176, 122.2844 +5816, 69.20081, 120.9584 +5817, 66.10694, 124.0101 +5818, 65.78863, 113.8094 +5819, 70.78459, 145.5794 +5820, 68.58712, 124.2324 +5821, 68.57242, 106.2736 +5822, 66.9078, 114.6637 +5823, 68.24046, 116.8464 +5824, 70.33099, 137.315 +5825, 66.34712, 121.422 +5826, 69.51991, 139.1533 +5827, 68.24002, 138.3138 +5828, 68.81582, 128.7253 +5829, 67.46373, 140.8966 +5830, 68.39019, 144.1242 +5831, 66.67797, 128.4131 +5832, 68.80968, 126.858 +5833, 69.4337, 131.1752 +5834, 66.65083, 125.386 +5835, 66.85582, 122.8987 +5836, 68.77332, 146.0516 +5837, 64.63102, 113.7093 +5838, 68.71508, 143.0982 +5839, 68.75348, 133.4762 +5840, 66.51489, 113.0104 +5841, 68.37401, 106.2333 +5842, 62.34907, 92.08858 +5843, 68.92916, 129.1092 +5844, 71.68363, 129.1334 +5845, 66.322, 110.1751 +5846, 69.50661, 131.645 +5847, 67.40328, 139.6598 +5848, 67.19077, 112.4249 +5849, 67.19175, 135.4273 +5850, 69.88968, 135.0597 +5851, 67.71483, 131.9399 +5852, 69.1943, 123.0009 +5853, 68.43015, 126.813 +5854, 71.52141, 135.1442 +5855, 66.03545, 124.7625 +5856, 66.75322, 110.7626 +5857, 67.97544, 132.68 +5858, 70.43693, 148.038 +5859, 66.97159, 129.2555 +5860, 64.39987, 122.562 +5861, 67.69987, 128.6123 +5862, 68.06251, 125.5895 +5863, 69.63558, 124.3082 +5864, 67.44679, 116.4591 +5865, 65.89161, 115.974 +5866, 69.51355, 124.6651 +5867, 63.64185, 117.6007 +5868, 66.78862, 117.3315 +5869, 67.36831, 144.5431 +5870, 64.77625, 146.0965 +5871, 69.18543, 122.701 +5872, 66.26194, 118.7813 +5873, 68.65178, 121.752 +5874, 69.14357, 161.7266 +5875, 68.66398, 123.2472 +5876, 70.5741, 132.7715 +5877, 67.54965, 126.7619 +5878, 68.71849, 130.7257 +5879, 67.01063, 120.9484 +5880, 67.36634, 127.3686 +5881, 68.16669, 147.874 +5882, 69.81134, 141.3724 +5883, 66.73085, 115.7089 +5884, 65.96768, 114.223 +5885, 66.26164, 125.0622 +5886, 70.12583, 124.0039 +5887, 66.31984, 120.267 +5888, 68.89732, 124.8329 +5889, 69.22677, 128.9729 +5890, 71.16343, 143.5928 +5891, 64.12514, 134.7727 +5892, 71.17117, 152.651 +5893, 66.91345, 120.0058 +5894, 66.64158, 118.8403 +5895, 66.52425, 123.8263 +5896, 70.46871, 145.1333 +5897, 65.93944, 122.5218 +5898, 66.70213, 133.2482 +5899, 64.60008, 113.2583 +5900, 67.22989, 124.304 +5901, 67.76131, 140.08 +5902, 65.63379, 111.9369 +5903, 69.74489, 135.7224 +5904, 69.74892, 125.5452 +5905, 66.1265, 121.3924 +5906, 69.56993, 134.1461 +5907, 69.4781, 129.5945 +5908, 69.251, 135.8543 +5909, 65.88081, 116.0534 +5910, 65.85276, 117.3475 +5911, 69.53098, 138.892 +5912, 67.702, 119.1475 +5913, 66.31858, 132.1847 +5914, 65.68324, 111.7099 +5915, 66.8561, 142.4656 +5916, 69.0744, 120.1102 +5917, 66.66269, 110.537 +5918, 66.5834, 127.299 +5919, 67.70926, 132.0492 +5920, 68.19135, 116.3223 +5921, 66.85165, 117.069 +5922, 68.99365, 124.2528 +5923, 68.96601, 130.3402 +5924, 70.93465, 137.3957 +5925, 69.53833, 133.2753 +5926, 66.13819, 107.2152 +5927, 66.02829, 110.0063 +5928, 70.24533, 149.8284 +5929, 67.86194, 117.9091 +5930, 67.23322, 126.0349 +5931, 67.50164, 113.9574 +5932, 71.23342, 140.2096 +5933, 69.88821, 151.7165 +5934, 67.85973, 117.4995 +5935, 69.22897, 129.2885 +5936, 65.35526, 120.6695 +5937, 65.52588, 112.762 +5938, 70.8509, 130.0362 +5939, 65.17021, 111.9882 +5940, 65.35895, 107.5214 +5941, 64.77466, 127.5588 +5942, 65.07433, 119.1591 +5943, 66.32264, 109.9997 +5944, 70.25829, 129.6662 +5945, 68.46057, 135.197 +5946, 67.32406, 133.8561 +5947, 69.53655, 132.6168 +5948, 66.72552, 111.4197 +5949, 69.04313, 109.6263 +5950, 67.63395, 123.3522 +5951, 67.68225, 130.9284 +5952, 67.20527, 132.5174 +5953, 68.57727, 113.3802 +5954, 69.81593, 124.0074 +5955, 67.27727, 111.7334 +5956, 70.77213, 140.6956 +5957, 64.39879, 112.6936 +5958, 67.32911, 119.5627 +5959, 68.56564, 137.7463 +5960, 70.12937, 128.2247 +5961, 70.50405, 111.7906 +5962, 67.69242, 135.8347 +5963, 66.15337, 123.5173 +5964, 67.04967, 121.4366 +5965, 67.14891, 132.7812 +5966, 68.06454, 131.8433 +5967, 66.40213, 141.9992 +5968, 68.74408, 123.0744 +5969, 68.28835, 129.5032 +5970, 68.49705, 148.1317 +5971, 69.61735, 131.6342 +5972, 65.46622, 118.5369 +5973, 68.4357, 102.342 +5974, 66.21604, 118.1429 +5975, 71.1547, 137.0264 +5976, 65.50148, 106.2971 +5977, 70.46899, 140.2618 +5978, 67.60018, 123 +5979, 69.30591, 123.2186 +5980, 65.67069, 122.2368 +5981, 67.36778, 117.442 +5982, 68.47589, 137.8969 +5983, 69.72743, 134.3279 +5984, 68.84393, 117.6781 +5985, 69.19121, 129.7261 +5986, 68.51219, 133.2155 +5987, 66.30328, 113.0214 +5988, 72.1518, 124.9451 +5989, 68.31371, 128.7378 +5990, 66.21908, 99.78213 +5991, 64.60633, 120.786 +5992, 70.23266, 127.1388 +5993, 68.73753, 144.4456 +5994, 69.49503, 132.1904 +5995, 67.25261, 137.7559 +5996, 71.46246, 141.305 +5997, 67.7491, 139.5633 +5998, 68.80025, 128.2314 +5999, 66.8725, 119.1075 +6000, 68.4765, 120.8274 +6001, 64.86316, 116.4621 +6002, 67.91753, 139.5891 +6003, 67.84233, 138.0376 +6004, 69.38148, 124.8913 +6005, 66.94613, 127.2921 +6006, 67.45924, 117.4689 +6007, 69.99586, 132.8246 +6008, 67.45856, 123.6045 +6009, 64.09151, 138.3749 +6010, 66.37835, 122.9717 +6011, 70.12316, 122.3759 +6012, 67.34219, 121.3154 +6013, 70.14728, 136.3431 +6014, 69.0379, 123.907 +6015, 67.0297, 107.5287 +6016, 64.85652, 130.1924 +6017, 65.94007, 109.5656 +6018, 64.69116, 115.9239 +6019, 62.53019, 109.5766 +6020, 67.78541, 124.236 +6021, 68.27657, 133.3359 +6022, 65.93553, 118.4802 +6023, 67.48252, 120.3425 +6024, 67.80949, 131.0862 +6025, 70.04498, 129.9862 +6026, 66.0988, 121.7657 +6027, 67.87462, 145.1821 +6028, 65.04519, 134.0519 +6029, 64.96125, 105.489 +6030, 64.82767, 112.1873 +6031, 70.08844, 137.1698 +6032, 70.70944, 142.7307 +6033, 66.80032, 123.4484 +6034, 67.14141, 120.8645 +6035, 67.04259, 135.9558 +6036, 68.48662, 148.4587 +6037, 72.31757, 144.881 +6038, 66.47968, 139.3578 +6039, 66.82557, 109.1264 +6040, 70.06934, 135.3785 +6041, 67.217, 113.8089 +6042, 67.12457, 148.5183 +6043, 68.4131, 144.8827 +6044, 66.02919, 114.9248 +6045, 66.84654, 114.9225 +6046, 68.94666, 122.8046 +6047, 68.91853, 133.5443 +6048, 65.5914, 131.9386 +6049, 65.51261, 120.6623 +6050, 69.27083, 145.653 +6051, 69.57316, 130.7801 +6052, 67.86325, 118.8413 +6053, 72.33364, 133.6214 +6054, 67.21175, 104.1953 +6055, 68.83481, 117.464 +6056, 68.46136, 145.8766 +6057, 68.1713, 135.6227 +6058, 69.69391, 129.1389 +6059, 67.12571, 149.7706 +6060, 70.36279, 134.1039 +6061, 71.4732, 143.9365 +6062, 68.51565, 132.4801 +6063, 70.06817, 149.4329 +6064, 68.04516, 132.5979 +6065, 67.47227, 133.6407 +6066, 70.56501, 147.4583 +6067, 67.64197, 100.025 +6068, 72.23026, 140.2179 +6069, 67.45255, 120.8849 +6070, 66.97768, 109.3834 +6071, 67.28894, 136.1833 +6072, 66.02667, 115.1345 +6073, 64.15728, 130.0889 +6074, 67.78574, 131.8054 +6075, 71.05897, 125.119 +6076, 68.55136, 149.0059 +6077, 71.11228, 129.2335 +6078, 65.22518, 120.5247 +6079, 67.13777, 123.2162 +6080, 67.98084, 117.4022 +6081, 67.45039, 106.9632 +6082, 67.58732, 119.6435 +6083, 67.40106, 134.1122 +6084, 69.75732, 129.9282 +6085, 67.78374, 130.1554 +6086, 65.01631, 106.8729 +6087, 68.98708, 126.6898 +6088, 67.84236, 115.7457 +6089, 70.91418, 130.1665 +6090, 68.44803, 110.8115 +6091, 63.23903, 119.8366 +6092, 66.75371, 113.1127 +6093, 66.13148, 118.4705 +6094, 66.57052, 135.6863 +6095, 68.43743, 111.4731 +6096, 68.12826, 129.3106 +6097, 65.66194, 116.9965 +6098, 68.64587, 128.6098 +6099, 67.01908, 137.8634 +6100, 66.3869, 135.486 +6101, 67.43419, 112.9047 +6102, 67.0218, 143.1287 +6103, 70.98964, 136.9279 +6104, 64.47574, 113.9935 +6105, 66.48783, 121.2945 +6106, 68.28864, 130.4347 +6107, 66.11987, 133.8865 +6108, 68.73539, 153.3002 +6109, 67.61776, 123.3522 +6110, 65.99257, 105.2183 +6111, 71.79273, 144.2173 +6112, 69.76151, 155.9849 +6113, 67.65103, 111.6875 +6114, 64.82727, 125.8154 +6115, 68.38678, 121.5078 +6116, 68.35981, 129.6506 +6117, 67.56773, 116.2672 +6118, 67.70372, 125.3254 +6119, 70.42781, 165.7172 +6120, 66.27416, 133.3637 +6121, 68.61263, 145.4779 +6122, 69.9746, 135.8348 +6123, 69.38629, 130.2342 +6124, 63.38805, 114.0297 +6125, 68.40181, 117.6173 +6126, 65.89607, 123.5651 +6127, 66.25442, 124.9826 +6128, 68.43563, 131.054 +6129, 68.43069, 152.1767 +6130, 67.44333, 118.6275 +6131, 68.75899, 112.2566 +6132, 65.87903, 127.7575 +6133, 67.3794, 120.4361 +6134, 67.20197, 104.816 +6135, 71.72566, 119.2446 +6136, 68.326, 125.8377 +6137, 69.07214, 131.3704 +6138, 70.39663, 125.35 +6139, 68.46942, 118.3351 +6140, 70.75069, 129.7989 +6141, 68.25077, 126.6471 +6142, 69.4218, 129.0352 +6143, 67.75693, 134.8437 +6144, 68.78237, 150.5262 +6145, 68.93468, 132.4508 +6146, 64.36411, 131.0136 +6147, 69.45069, 151.8922 +6148, 68.70335, 122.5303 +6149, 69.17716, 127.2585 +6150, 73.32701, 147.9296 +6151, 69.01245, 108.8242 +6152, 65.2012, 127.7629 +6153, 67.65215, 130.3 +6154, 68.59028, 124.4653 +6155, 70.1527, 159.2435 +6156, 70.35282, 130.4261 +6157, 67.14863, 144.1876 +6158, 72.11654, 136.8595 +6159, 64.54112, 105.9232 +6160, 68.94058, 131.888 +6161, 68.18651, 129.5985 +6162, 72.69199, 121.7006 +6163, 68.2263, 128.3129 +6164, 70.40403, 130.5713 +6165, 65.32887, 126.0176 +6166, 65.29057, 109.782 +6167, 65.58939, 109.7956 +6168, 65.28916, 128.021 +6169, 69.91649, 132.3785 +6170, 66.59848, 127.7981 +6171, 69.24885, 133.7892 +6172, 68.81944, 124.2264 +6173, 68.79688, 122.0913 +6174, 67.19139, 127.5538 +6175, 68.40568, 142.3945 +6176, 70.58364, 135.3762 +6177, 68.401, 143.1102 +6178, 70.95629, 139.016 +6179, 69.85706, 120.7675 +6180, 65.61593, 129.3528 +6181, 65.39064, 96.54815 +6182, 67.95175, 128.2412 +6183, 70.05209, 123.2307 +6184, 68.18199, 134.9267 +6185, 68.79938, 116.6928 +6186, 67.36607, 118.689 +6187, 70.62204, 125.7371 +6188, 71.7953, 158.2326 +6189, 66.53015, 117.0002 +6190, 65.09768, 134.3973 +6191, 64.76077, 128.8129 +6192, 69.03578, 130.8927 +6193, 65.44403, 109.9232 +6194, 66.15236, 110.353 +6195, 69.55012, 138.8793 +6196, 64.92792, 116.1101 +6197, 67.75727, 122.6048 +6198, 69.05062, 143.6487 +6199, 64.93136, 94.59876 +6200, 70.18691, 130.8536 +6201, 67.72971, 148.7955 +6202, 67.32869, 130.6884 +6203, 69.70995, 151.1615 +6204, 71.38761, 144.922 +6205, 67.33116, 132.6171 +6206, 68.52212, 120.6801 +6207, 70.20145, 117.236 +6208, 66.58931, 117.0805 +6209, 69.02084, 131.2609 +6210, 68.78726, 123.945 +6211, 69.06258, 120.0654 +6212, 70.13521, 126.9799 +6213, 69.71943, 136.3826 +6214, 69.37398, 131.2544 +6215, 69.05735, 132.3124 +6216, 70.05472, 132.6614 +6217, 68.34561, 133.09 +6218, 67.52209, 121.4611 +6219, 70.0784, 133.6073 +6220, 68.1606, 142.0494 +6221, 66.76219, 133.1326 +6222, 67.39828, 119.6178 +6223, 69.23848, 129.4479 +6224, 63.37741, 121.7897 +6225, 68.52886, 129.8267 +6226, 66.21498, 131.2149 +6227, 66.87539, 136.5157 +6228, 67.37879, 113.5019 +6229, 66.66129, 133.4427 +6230, 68.08244, 133.4736 +6231, 65.97344, 135.5212 +6232, 65.8609, 122.3441 +6233, 67.68464, 124.7005 +6234, 69.1243, 126.6651 +6235, 71.24086, 127.2719 +6236, 69.075, 125.6317 +6237, 69.07254, 128.9997 +6238, 65.76779, 121.7671 +6239, 69.5003, 142.9457 +6240, 69.21009, 129.2261 +6241, 66.131, 128.9078 +6242, 66.45404, 109.0055 +6243, 65.43012, 129.1382 +6244, 68.37789, 132.0082 +6245, 69.25871, 126.1872 +6246, 68.55917, 131.6865 +6247, 69.82956, 152.9133 +6248, 68.56366, 135.9443 +6249, 69.89716, 135.4161 +6250, 67.22911, 126.9908 +6251, 68.27784, 151.4986 +6252, 67.70956, 120.9284 +6253, 68.63497, 143.909 +6254, 66.24494, 148.3015 +6255, 65.9282, 98.38391 +6256, 68.6507, 134.6537 +6257, 67.66363, 91.26068 +6258, 68.1538, 129.1524 +6259, 63.79264, 116.3877 +6260, 65.46251, 128.8832 +6261, 70.75386, 135.3328 +6262, 66.29608, 119.843 +6263, 66.17127, 132.3032 +6264, 70.22032, 129.6479 +6265, 68.38254, 135.7889 +6266, 68.72417, 119.4445 +6267, 69.03554, 131.3376 +6268, 69.23422, 119.5137 +6269, 68.75012, 142.7779 +6270, 68.70768, 142.0977 +6271, 67.9005, 125.3087 +6272, 69.60629, 146.4574 +6273, 66.8099, 129.1352 +6274, 65.01465, 100.5445 +6275, 67.35337, 131.1702 +6276, 63.03599, 112.098 +6277, 68.79753, 117.0905 +6278, 68.69337, 132.2144 +6279, 66.37421, 123.5625 +6280, 68.3918, 123.9172 +6281, 66.86315, 123.8108 +6282, 69.64423, 130.3421 +6283, 68.98795, 128.7153 +6284, 68.7025, 131.4076 +6285, 67.0616, 110.9624 +6286, 67.14099, 120.8645 +6287, 66.31361, 127.8163 +6288, 69.6794, 140.4675 +6289, 66.24529, 117.5554 +6290, 66.79284, 138.8735 +6291, 69.9798, 132.5518 +6292, 68.20436, 144.968 +6293, 67.80794, 141.1958 +6294, 71.49761, 146.9498 +6295, 71.80853, 136.9644 +6296, 67.83517, 137.1286 +6297, 68.34113, 129.0216 +6298, 69.08567, 117.0247 +6299, 66.75809, 141.0586 +6300, 65.40628, 126.6997 +6301, 65.53954, 119.8531 +6302, 69.0588, 111.6993 +6303, 67.7959, 117.9009 +6304, 71.39265, 118.7488 +6305, 66.70088, 131.8821 +6306, 69.67472, 140.8053 +6307, 69.23373, 138.6932 +6308, 70.9753, 143.1101 +6309, 67.65321, 129.5612 +6310, 65.60536, 117.7563 +6311, 67.32889, 135.7928 +6312, 69.521, 128.0812 +6313, 67.66563, 121.5679 +6314, 67.22662, 130.5827 +6315, 67.13201, 118.4574 +6316, 67.2819, 119.473 +6317, 66.45431, 116.4503 +6318, 68.42039, 142.5478 +6319, 67.14612, 122.8747 +6320, 62.98619, 113.4143 +6321, 63.66845, 131.0824 +6322, 65.28612, 104.5026 +6323, 64.30048, 106.3191 +6324, 66.10993, 103.9913 +6325, 65.91527, 125.8579 +6326, 67.82866, 125.7767 +6327, 69.87356, 131.063 +6328, 66.24116, 112.8657 +6329, 66.05187, 121.3259 +6330, 65.53557, 119.5436 +6331, 67.6665, 144.1403 +6332, 68.3058, 119.0695 +6333, 70.74075, 137.7395 +6334, 67.06837, 122.4245 +6335, 69.88488, 145.2255 +6336, 69.24424, 141.3037 +6337, 68.25133, 115.4675 +6338, 67.09232, 138.4092 +6339, 69.06273, 112.7855 +6340, 68.33125, 131.4942 +6341, 68.94119, 134.7967 +6342, 69.59518, 115.4751 +6343, 71.28803, 157.5443 +6344, 66.42491, 127.2222 +6345, 68.63305, 131.8311 +6346, 66.21553, 111.216 +6347, 67.47736, 116.7243 +6348, 64.51185, 86.49925 +6349, 67.33792, 126.9632 +6350, 67.41203, 125.8066 +6351, 67.89703, 126.1505 +6352, 65.08935, 122.4771 +6353, 70.58024, 139.0572 +6354, 70.26786, 124.0146 +6355, 68.09574, 138.602 +6356, 70.04702, 133.2217 +6357, 67.1535, 115.3322 +6358, 67.87558, 127.5807 +6359, 72.24161, 144.0286 +6360, 70.21055, 131.3894 +6361, 68.77272, 134.0195 +6362, 68.96749, 122.9673 +6363, 66.95136, 111.7026 +6364, 69.70156, 132.0676 +6365, 64.13956, 93.09256 +6366, 71.56149, 153.1117 +6367, 68.86042, 153.6386 +6368, 66.79593, 127.4353 +6369, 64.54504, 113.8478 +6370, 70.00599, 142.7425 +6371, 69.19904, 145.2462 +6372, 69.09444, 140.8653 +6373, 67.19525, 105.4341 +6374, 67.96947, 105.7521 +6375, 70.02533, 139.9395 +6376, 66.87761, 122.6013 +6377, 64.45014, 131.0252 +6378, 68.24912, 135.3378 +6379, 70.07101, 152.8499 +6380, 66.9759, 113.9803 +6381, 70.36787, 140.2859 +6382, 68.6591, 146.4581 +6383, 69.95361, 141.0113 +6384, 68.48425, 128.0158 +6385, 71.25946, 164.5588 +6386, 67.80922, 130.3115 +6387, 63.58671, 117.3091 +6388, 67.40848, 135.3097 +6389, 68.20701, 128.4742 +6390, 68.89247, 124.929 +6391, 66.05981, 117.8305 +6392, 65.66067, 123.4769 +6393, 69.39748, 133.3201 +6394, 65.92174, 108.8612 +6395, 64.78001, 102.3802 +6396, 67.59062, 117.6786 +6397, 71.00127, 149.2434 +6398, 69.48254, 121.6221 +6399, 68.48246, 159.2052 +6400, 68.09616, 133.6355 +6401, 69.48115, 122.3265 +6402, 70.50577, 141.2895 +6403, 69.5883, 140.0531 +6404, 69.31491, 124.1149 +6405, 68.39399, 139.9906 +6406, 62.23548, 94.80998 +6407, 69.8972, 148.2548 +6408, 68.06989, 146.5246 +6409, 69.12319, 111.1013 +6410, 69.95192, 126.322 +6411, 67.93156, 137.8815 +6412, 69.32167, 130.0449 +6413, 66.67312, 141.5919 +6414, 67.96604, 123.8124 +6415, 69.19829, 130.9459 +6416, 68.15828, 114.9747 +6417, 68.03235, 116.2177 +6418, 68.43761, 102.8575 +6419, 67.34517, 103.4353 +6420, 68.64435, 127.6291 +6421, 64.83459, 112.7336 +6422, 64.11121, 111.5238 +6423, 67.52032, 101.0851 +6424, 66.72676, 128.6718 +6425, 68.76169, 132.1914 +6426, 68.50268, 123.0143 +6427, 67.35174, 122.898 +6428, 66.64565, 123.7642 +6429, 67.11109, 120.5121 +6430, 67.92539, 140.0124 +6431, 65.7078, 116.2137 +6432, 67.65793, 138.142 +6433, 68.60162, 134.1922 +6434, 69.30603, 130.9022 +6435, 67.1095, 137.4821 +6436, 65.59186, 103.921 +6437, 67.66742, 139.2905 +6438, 68.63966, 112.1105 +6439, 64.7652, 92.20107 +6440, 67.60131, 120.6972 +6441, 67.31966, 126.8577 +6442, 66.51157, 122.8182 +6443, 69.93026, 135.7746 +6444, 67.60868, 131.5309 +6445, 65.7309, 121.011 +6446, 67.29622, 118.9762 +6447, 66.84201, 120.7153 +6448, 67.91374, 137.0166 +6449, 65.33921, 109.9667 +6450, 67.10739, 127.3581 +6451, 66.39279, 131.2489 +6452, 65.77143, 118.5557 +6453, 66.08581, 122.4064 +6454, 67.95467, 136.8644 +6455, 63.31058, 113.5932 +6456, 70.10242, 123.0639 +6457, 69.72937, 130.3103 +6458, 67.62461, 118.9278 +6459, 69.23113, 111.379 +6460, 67.38459, 116.0054 +6461, 70.68647, 146.7535 +6462, 71.42291, 141.3565 +6463, 68.60167, 112.7169 +6464, 65.01908, 120.2538 +6465, 68.22216, 137.5639 +6466, 66.18504, 122.2857 +6467, 67.34507, 122.5287 +6468, 69.8637, 134.646 +6469, 68.63027, 121.5066 +6470, 69.01165, 130.7259 +6471, 68.57992, 116.8032 +6472, 70.02954, 135.12 +6473, 67.8609, 130.8429 +6474, 67.071, 128.6312 +6475, 67.25316, 121.6315 +6476, 68.45752, 138.1129 +6477, 66.08131, 110.8231 +6478, 65.5926, 104.7464 +6479, 68.56861, 118.8964 +6480, 69.69795, 143.2327 +6481, 66.67277, 108.3892 +6482, 61.59011, 99.81074 +6483, 65.40277, 114.1857 +6484, 68.44756, 127.5778 +6485, 66.73714, 118.4245 +6486, 72.205, 154.2642 +6487, 68.46802, 121.7574 +6488, 70.10294, 142.4799 +6489, 66.48949, 112.2608 +6490, 67.19112, 121.4096 +6491, 65.22879, 121.375 +6492, 67.00396, 127.1951 +6493, 67.72317, 107.6196 +6494, 70.09165, 152.4262 +6495, 66.07538, 128.1418 +6496, 66.91173, 146.0408 +6497, 68.65328, 117.6621 +6498, 67.75543, 135.4845 +6499, 66.36233, 131.4949 +6500, 67.6272, 127.833 +6501, 68.21944, 123.405 +6502, 67.57571, 136.8255 +6503, 67.02379, 137.789 +6504, 67.57237, 141.6039 +6505, 65.6522, 109.4063 +6506, 65.44991, 102.5063 +6507, 70.32828, 163.8992 +6508, 69.08622, 118.9012 +6509, 68.33335, 126.7698 +6510, 66.29224, 134.6024 +6511, 68.16586, 120.86 +6512, 66.04152, 136.2559 +6513, 70.48553, 147.5044 +6514, 66.67757, 125.5265 +6515, 66.65461, 115.3878 +6516, 69.63744, 140.8728 +6517, 67.68649, 108.0794 +6518, 66.58507, 98.00565 +6519, 68.3482, 119.2853 +6520, 68.92806, 112.4171 +6521, 68.53403, 146.0566 +6522, 71.3806, 133.3801 +6523, 70.11959, 152.4782 +6524, 66.25934, 130.2875 +6525, 69.53489, 155.4037 +6526, 67.46936, 139.8139 +6527, 66.51039, 119.1722 +6528, 69.92009, 138.286 +6529, 67.79021, 107.2949 +6530, 66.83271, 108.3566 +6531, 70.99707, 117.9595 +6532, 66.68384, 130.0104 +6533, 65.32131, 105.6657 +6534, 67.3587, 115.0555 +6535, 64.04389, 103.6805 +6536, 67.25724, 117.0895 +6537, 70.83582, 129.5163 +6538, 69.2102, 129.1965 +6539, 65.91382, 119.2019 +6540, 68.89983, 128.3612 +6541, 68.6346, 133.2154 +6542, 65.36955, 121.3485 +6543, 66.25718, 109.8669 +6544, 69.18027, 130.5783 +6545, 69.53816, 118.921 +6546, 66.66547, 122.2455 +6547, 69.35299, 131.5557 +6548, 65.99078, 103.7061 +6549, 67.55311, 134.4433 +6550, 65.95292, 130.1628 +6551, 69.74893, 109.4178 +6552, 68.13165, 120.4415 +6553, 64.53068, 114.9703 +6554, 65.95702, 132.643 +6555, 70.27411, 120.3263 +6556, 68.30787, 132.9732 +6557, 69.93158, 136.795 +6558, 68.76325, 128.7979 +6559, 68.68206, 142.8603 +6560, 68.32988, 133.13 +6561, 68.04129, 143.2981 +6562, 67.9522, 117.0683 +6563, 65.7157, 118.3454 +6564, 72.12643, 124.3554 +6565, 66.79918, 118.7239 +6566, 67.49036, 123.5892 +6567, 66.88022, 126.7582 +6568, 68.25984, 137.6865 +6569, 66.6257, 130.5098 +6570, 64.15701, 113.9842 +6571, 65.30643, 110.9035 +6572, 71.83145, 146.3799 +6573, 68.43502, 128.2374 +6574, 64.79043, 115.6001 +6575, 69.24446, 129.4057 +6576, 70.28435, 125.6591 +6577, 72.99453, 126.8912 +6578, 70.41651, 131.3277 +6579, 65.79611, 132.5054 +6580, 69.49913, 129.3703 +6581, 65.87009, 110.5038 +6582, 65.0852, 106.2354 +6583, 70.61194, 129.5963 +6584, 71.39877, 131.9176 +6585, 66.29704, 122.9437 +6586, 65.64143, 121.4597 +6587, 69.78249, 138.3473 +6588, 68.32625, 135.247 +6589, 69.02806, 100.8881 +6590, 68.87437, 122.2625 +6591, 66.7959, 119.0778 +6592, 68.62814, 139.7986 +6593, 71.19139, 136.2042 +6594, 65.4116, 122.3825 +6595, 68.84184, 134.2696 +6596, 68.8806, 123.1216 +6597, 65.73631, 127.6449 +6598, 69.30987, 131.7523 +6599, 64.15534, 114.2796 +6600, 72.89442, 133.7642 +6601, 66.41814, 142.6604 +6602, 65.886, 119.2969 +6603, 69.06664, 131.9619 +6604, 67.96217, 125.9612 +6605, 68.68041, 131.3237 +6606, 68.515, 118.9934 +6607, 67.37231, 127.9334 +6608, 63.67556, 114.3381 +6609, 65.76516, 123.8141 +6610, 68.71711, 137.0437 +6611, 69.62402, 119.3894 +6612, 66.8157, 107.8753 +6613, 64.54403, 123.3058 +6614, 68.37687, 116.9408 +6615, 67.70961, 120.4639 +6616, 69.79282, 107.1216 +6617, 70.33109, 134.1242 +6618, 71.11525, 142.3554 +6619, 70.50683, 131.8652 +6620, 67.3265, 117.8718 +6621, 70.37423, 134.2731 +6622, 68.93535, 136.6499 +6623, 68.74748, 139.4778 +6624, 66.31697, 126.7884 +6625, 67.96141, 137.7632 +6626, 68.02516, 125.7112 +6627, 68.54611, 134.6283 +6628, 73.72628, 142.811 +6629, 66.30109, 124.8609 +6630, 69.84513, 134.2394 +6631, 66.34608, 112.6472 +6632, 69.22406, 120.5706 +6633, 65.20241, 126.6356 +6634, 68.16207, 122.2711 +6635, 66.17376, 114.6814 +6636, 65.82561, 137.7805 +6637, 70.49243, 122.7935 +6638, 66.86335, 129.0675 +6639, 69.00819, 121.8091 +6640, 69.09268, 139.8642 +6641, 68.4858, 137.6952 +6642, 70.05821, 124.648 +6643, 63.92011, 136.3251 +6644, 69.10662, 124.9316 +6645, 68.37383, 124.5664 +6646, 67.81685, 147.8495 +6647, 68.35014, 121.062 +6648, 66.20868, 134.3163 +6649, 69.82296, 145.8658 +6650, 69.83591, 128.6599 +6651, 70.09777, 148.3039 +6652, 65.74923, 118.5265 +6653, 67.2496, 121.1303 +6654, 67.01302, 106.3264 +6655, 67.86604, 142.5205 +6656, 69.51352, 143.2796 +6657, 68.79671, 119.9716 +6658, 71.3044, 142.1026 +6659, 68.74348, 130.4 +6660, 68.21948, 129.4293 +6661, 72.8674, 128.4835 +6662, 67.8235, 113.0689 +6663, 65.2038, 116.4099 +6664, 64.55504, 115.4541 +6665, 68.46274, 121.7866 +6666, 66.08879, 114.1458 +6667, 66.53332, 109.2672 +6668, 66.75524, 102.657 +6669, 68.20629, 130.9008 +6670, 69.60968, 141.8457 +6671, 65.68272, 138.0014 +6672, 66.5195, 122.4759 +6673, 63.30338, 120.175 +6674, 67.19227, 115.3758 +6675, 64.59287, 115.1326 +6676, 67.61165, 134.6538 +6677, 69.54174, 123.5377 +6678, 72.4977, 133.2865 +6679, 68.60441, 135.2291 +6680, 68.26375, 118.0737 +6681, 66.51715, 125.0585 +6682, 66.7498, 134.2382 +6683, 68.57715, 126.5512 +6684, 68.15554, 118.1801 +6685, 67.67131, 116.6818 +6686, 69.25188, 149.0548 +6687, 67.63059, 122.7405 +6688, 70.5553, 128.8346 +6689, 66.51049, 122.1635 +6690, 70.06291, 134.2863 +6691, 68.95425, 140.8941 +6692, 67.76337, 115.7462 +6693, 66.16295, 122.7829 +6694, 70.23017, 148.6758 +6695, 66.85157, 128.1767 +6696, 69.98998, 135.2626 +6697, 69.57826, 129.3778 +6698, 67.82307, 113.7661 +6699, 66.16931, 118.1876 +6700, 64.97487, 119.7272 +6701, 66.75172, 111.0794 +6702, 67.03147, 122.6207 +6703, 70.78522, 149.449 +6704, 69.08702, 127.2521 +6705, 66.56877, 140.5165 +6706, 65.65581, 103.6644 +6707, 69.91828, 129.1403 +6708, 68.10072, 143.8415 +6709, 65.21574, 115.4829 +6710, 65.92987, 131.1892 +6711, 66.78368, 134.2093 +6712, 66.63773, 137.8539 +6713, 70.115, 136.2478 +6714, 71.87742, 145.386 +6715, 69.37969, 143.8422 +6716, 67.09682, 120.5931 +6717, 68.90441, 122.8529 +6718, 67.59411, 124.496 +6719, 69.73864, 107.3653 +6720, 66.47251, 136.4277 +6721, 68.96672, 149.0714 +6722, 69.183, 137.1885 +6723, 69.12592, 137.31 +6724, 67.06716, 139.6149 +6725, 66.43504, 116.7063 +6726, 68.03354, 133.7463 +6727, 70.66473, 134.2961 +6728, 66.95512, 118.338 +6729, 71.13236, 144.4866 +6730, 64.10697, 120.6126 +6731, 69.43162, 145.1667 +6732, 67.23457, 113.2283 +6733, 70.20178, 112.7536 +6734, 65.73987, 123.1815 +6735, 66.55121, 121.9317 +6736, 67.72679, 119.4187 +6737, 71.22324, 132.9604 +6738, 64.72674, 127.4027 +6739, 67.36195, 122.3824 +6740, 68.42406, 132.2244 +6741, 69.81064, 124.3983 +6742, 70.14812, 111.3963 +6743, 66.31497, 123.1817 +6744, 67.25945, 103.6091 +6745, 66.24777, 123.5493 +6746, 67.13633, 142.1095 +6747, 68.44022, 129.7913 +6748, 72.07034, 136.4478 +6749, 68.48039, 120.6969 +6750, 67.12369, 122.3988 +6751, 67.94203, 138.1901 +6752, 68.01522, 119.8895 +6753, 67.83753, 110.6977 +6754, 67.08281, 131.6536 +6755, 66.13397, 125.3077 +6756, 70.17398, 138.519 +6757, 73.12686, 139.2637 +6758, 66.29478, 132.4121 +6759, 67.48723, 128.3885 +6760, 63.84013, 127.6618 +6761, 71.23226, 137.9139 +6762, 68.93456, 131.205 +6763, 65.31508, 126.5417 +6764, 72.89094, 144.8666 +6765, 66.85445, 123.4989 +6766, 67.71429, 129.7462 +6767, 66.99515, 145.3356 +6768, 62.48643, 115.2889 +6769, 68.4545, 119.9549 +6770, 66.18029, 112.1502 +6771, 68.29449, 127.8367 +6772, 68.5935, 137.6326 +6773, 68.13211, 121.9201 +6774, 70.55532, 131.9945 +6775, 71.26895, 135.8511 +6776, 70.71689, 133.3027 +6777, 68.27433, 123.0711 +6778, 65.85545, 125.7077 +6779, 67.19789, 130.9707 +6780, 69.03473, 143.7162 +6781, 70.96078, 138.1647 +6782, 68.99354, 146.7285 +6783, 66.75706, 133.1515 +6784, 67.73694, 123.5134 +6785, 68.31951, 129.2444 +6786, 66.24969, 121.9078 +6787, 68.70678, 128.4009 +6788, 68.0356, 140.9392 +6789, 68.96343, 137.3493 +6790, 67.50309, 129.5348 +6791, 65.02611, 131.0273 +6792, 70.0671, 146.3213 +6793, 65.36984, 97.06459 +6794, 66.73719, 119.8514 +6795, 68.25009, 124.1159 +6796, 68.91447, 144.9636 +6797, 69.42874, 117.0746 +6798, 69.11436, 126.7865 +6799, 67.99857, 112.9692 +6800, 70.26098, 141.588 +6801, 68.64432, 124.0298 +6802, 66.17354, 125.5482 +6803, 70.00471, 122.1783 +6804, 66.31189, 118.2902 +6805, 65.90206, 116.5597 +6806, 68.25885, 116.5077 +6807, 70.75448, 147.473 +6808, 67.08351, 131.7851 +6809, 67.02122, 132.2825 +6810, 70.51041, 134.3807 +6811, 67.60778, 119.8518 +6812, 68.83486, 136.1642 +6813, 64.254, 114.5097 +6814, 71.91722, 138.2213 +6815, 67.82529, 133.2127 +6816, 66.34443, 126.5382 +6817, 69.22459, 129.8661 +6818, 65.53683, 122.7073 +6819, 66.65738, 111.8648 +6820, 69.74106, 128.2887 +6821, 68.77304, 120.5732 +6822, 67.66713, 122.1059 +6823, 71.04389, 145.6585 +6824, 67.97438, 116.155 +6825, 69.01111, 137.4236 +6826, 70.97446, 137.894 +6827, 66.09937, 114.8329 +6828, 68.2026, 136.3654 +6829, 71.18778, 148.7839 +6830, 70.10012, 118.7125 +6831, 67.40562, 118.3544 +6832, 71.0495, 152.5436 +6833, 69.10354, 128.9651 +6834, 66.99674, 124.5497 +6835, 67.55177, 118.077 +6836, 66.04561, 100.3573 +6837, 69.97684, 120.8445 +6838, 69.59421, 136.3666 +6839, 69.50004, 129.3228 +6840, 66.70728, 129.9114 +6841, 67.74378, 116.261 +6842, 69.52156, 137.5933 +6843, 68.65583, 106.9772 +6844, 66.58063, 118.7891 +6845, 67.31123, 127.0282 +6846, 69.21023, 135.7681 +6847, 69.76802, 127.8121 +6848, 71.36846, 127.9637 +6849, 64.91466, 121.4664 +6850, 65.91717, 100.2395 +6851, 68.79172, 115.6267 +6852, 66.86831, 124.0965 +6853, 68.85311, 124.2217 +6854, 64.99322, 112.2167 +6855, 70.31634, 132.5438 +6856, 65.07995, 107.1524 +6857, 68.55692, 119.8364 +6858, 65.03755, 123.5259 +6859, 68.97846, 134.4521 +6860, 68.1677, 125.5112 +6861, 70.25241, 133.5386 +6862, 68.35771, 133.3158 +6863, 71.59998, 144.3195 +6864, 67.62775, 140.8419 +6865, 71.9168, 147.5959 +6866, 64.91759, 114.7572 +6867, 68.03944, 117.7686 +6868, 68.83719, 140.7958 +6869, 68.42447, 134.2855 +6870, 67.19277, 110.2144 +6871, 67.95936, 107.3158 +6872, 69.13031, 122.8845 +6873, 66.53698, 118.2503 +6874, 69.3362, 125.8938 +6875, 69.66919, 127.4892 +6876, 69.32642, 153.3295 +6877, 71.67815, 124.592 +6878, 66.81763, 106.8565 +6879, 67.96098, 133.7046 +6880, 70.27599, 124.6664 +6881, 70.83387, 132.0587 +6882, 71.95684, 138.0874 +6883, 65.53739, 130.3727 +6884, 67.20098, 118.1746 +6885, 66.84158, 134.8257 +6886, 72.22081, 123.7257 +6887, 68.23933, 128.9637 +6888, 69.34904, 151.0629 +6889, 67.54027, 126.6496 +6890, 66.55953, 114.8614 +6891, 69.42919, 133.6709 +6892, 68.77479, 137.1665 +6893, 67.11564, 139.5681 +6894, 69.7283, 127.7704 +6895, 69.71847, 119.206 +6896, 67.00926, 131.5259 +6897, 70.23583, 124.1454 +6898, 68.05243, 140.9604 +6899, 66.81973, 111.675 +6900, 64.33826, 131.6378 +6901, 69.21901, 133.7032 +6902, 70.30269, 133.0611 +6903, 67.7681, 115.596 +6904, 68.28813, 127.7475 +6905, 70.67229, 136.774 +6906, 67.56648, 135.1199 +6907, 68.2033, 117.4256 +6908, 70.82652, 128.3953 +6909, 68.76882, 124.6462 +6910, 66.21644, 140.4212 +6911, 69.94665, 129.9599 +6912, 66.82673, 116.1417 +6913, 70.62106, 138.8435 +6914, 65.96267, 131.9172 +6915, 68.32852, 120.174 +6916, 68.14281, 117.9655 +6917, 67.68342, 132.2259 +6918, 62.29058, 100.38 +6919, 66.56289, 112.8575 +6920, 67.53601, 127.3499 +6921, 69.9728, 128.0357 +6922, 71.62721, 148.2612 +6923, 68.87831, 118.697 +6924, 68.90985, 125.1128 +6925, 68.48804, 126.9495 +6926, 64.492, 116.0879 +6927, 68.05258, 130.1563 +6928, 70.97223, 128.6877 +6929, 67.73294, 124.8016 +6930, 64.42714, 122.3703 +6931, 66.89249, 121.6673 +6932, 72.00652, 126.211 +6933, 67.8034, 127.3033 +6934, 70.31843, 133.3873 +6935, 69.6285, 136.3986 +6936, 68.90652, 112.0078 +6937, 71.01122, 146.1389 +6938, 69.03379, 126.0906 +6939, 64.16792, 100.7711 +6940, 67.46005, 132.1034 +6941, 66.31981, 142.7429 +6942, 61.4055, 119.2652 +6943, 69.07292, 123.567 +6944, 69.04136, 129.2791 +6945, 65.63933, 130.0454 +6946, 68.98367, 146.821 +6947, 67.08789, 102.0192 +6948, 66.9645, 122.3346 +6949, 64.88959, 113.4712 +6950, 70.18743, 134.5754 +6951, 70.24701, 136.6864 +6952, 68.65855, 127.6595 +6953, 66.65856, 112.9117 +6954, 70.81437, 139.8524 +6955, 62.86676, 100.8983 +6956, 70.1981, 134.0086 +6957, 67.74387, 134.1832 +6958, 67.78774, 124.2984 +6959, 66.8155, 113.8397 +6960, 70.47312, 126.8411 +6961, 67.28529, 138.4671 +6962, 67.63923, 135.8226 +6963, 69.54133, 134.1394 +6964, 72.09163, 147.1709 +6965, 69.40312, 124.7091 +6966, 66.90419, 128.6304 +6967, 64.77967, 126.6038 +6968, 67.71305, 117.6067 +6969, 67.98558, 131.2976 +6970, 67.39091, 130.2718 +6971, 66.59739, 123.9308 +6972, 66.03491, 111.1245 +6973, 71.32563, 150.9399 +6974, 70.89299, 138.5366 +6975, 69.29039, 123.6542 +6976, 72.50612, 135.4202 +6977, 66.39209, 131.7184 +6978, 70.22429, 148.9964 +6979, 70.61033, 129.818 +6980, 67.43213, 113.7404 +6981, 67.08964, 142.8879 +6982, 69.52539, 133.248 +6983, 64.80112, 123.5309 +6984, 69.50292, 131.3393 +6985, 68.89136, 138.7052 +6986, 69.82676, 121.5695 +6987, 66.19549, 134.9518 +6988, 67.74861, 107.9783 +6989, 66.53997, 122.5054 +6990, 67.32858, 140.5876 +6991, 65.01159, 113.4278 +6992, 68.85847, 115.1244 +6993, 67.21657, 126.9035 +6994, 68.82472, 122.0827 +6995, 68.38527, 117.6941 +6996, 67.5943, 112.418 +6997, 67.82269, 110.7359 +6998, 67.83166, 134.7077 +6999, 66.31882, 124.513 +7000, 66.99476, 100.1673 +7001, 66.87892, 122.5671 +7002, 68.38919, 139.537 +7003, 66.4759, 123.509 +7004, 68.5542, 137.4336 +7005, 67.83647, 131.4485 +7006, 70.39431, 148.3386 +7007, 67.58981, 127.5607 +7008, 65.26024, 107.7349 +7009, 66.7406, 119.5494 +7010, 68.93702, 135.9338 +7011, 66.45697, 129.6703 +7012, 67.80572, 138.3332 +7013, 65.5528, 111.1973 +7014, 66.09202, 109.7177 +7015, 67.50397, 138.7697 +7016, 68.11816, 117.8952 +7017, 67.24076, 118.436 +7018, 66.5412, 139.4789 +7019, 71.02195, 140.13 +7020, 68.32773, 106.9353 +7021, 69.9594, 123.1594 +7022, 68.32581, 130.2541 +7023, 69.1247, 127.0935 +7024, 66.52031, 141.2168 +7025, 66.54596, 106.5251 +7026, 68.83517, 135.2336 +7027, 69.46929, 116.2368 +7028, 63.84823, 107.2539 +7029, 67.369, 125.2445 +7030, 66.46618, 126.7497 +7031, 68.00188, 124.7855 +7032, 66.55544, 130.3081 +7033, 67.93518, 129.0813 +7034, 71.09441, 136.352 +7035, 71.90701, 127.3129 +7036, 66.45996, 115.5565 +7037, 66.28668, 122.6641 +7038, 67.60595, 121.1687 +7039, 66.90904, 123.3812 +7040, 66.93917, 138.1009 +7041, 68.73882, 142.0686 +7042, 69.22875, 140.783 +7043, 67.50325, 118.1483 +7044, 68.374, 116.9901 +7045, 65.04856, 134.1878 +7046, 67.64236, 128.8601 +7047, 66.68778, 127.995 +7048, 68.92306, 110.6146 +7049, 68.29892, 147.2812 +7050, 69.50429, 124.4182 +7051, 71.313, 154.0956 +7052, 68.43807, 138.7187 +7053, 67.13923, 118.2185 +7054, 71.65034, 129.9864 +7055, 65.08982, 108.6521 +7056, 65.9342, 121.5126 +7057, 69.09728, 131.8032 +7058, 67.26581, 122.3023 +7059, 64.38799, 117.6848 +7060, 66.66263, 123.165 +7061, 69.12113, 128.1987 +7062, 68.00116, 120.519 +7063, 66.01521, 132.6177 +7064, 69.06381, 153.8047 +7065, 65.36307, 114.7964 +7066, 68.5666, 120.8603 +7067, 64.96461, 110.8094 +7068, 68.04672, 116.8675 +7069, 68.55896, 140.4034 +7070, 68.99092, 118.0107 +7071, 66.53254, 116.871 +7072, 65.54329, 99.65617 +7073, 66.37032, 123.1376 +7074, 67.35006, 131.78 +7075, 67.37973, 107.3991 +7076, 68.37168, 125.2837 +7077, 69.43348, 140.256 +7078, 68.83415, 126.4995 +7079, 68.35128, 132.1206 +7080, 69.7299, 126.5069 +7081, 66.76921, 116.9988 +7082, 68.59913, 113.4002 +7083, 66.77606, 114.8109 +7084, 66.92936, 108.9786 +7085, 69.08265, 137.5979 +7086, 69.06212, 122.6742 +7087, 66.44597, 120.8244 +7088, 70.37422, 139.8095 +7089, 64.52265, 117.7043 +7090, 67.58351, 149.6098 +7091, 70.31109, 139.4191 +7092, 70.50002, 137.8864 +7093, 66.50098, 113.2406 +7094, 65.35631, 117.0282 +7095, 67.80355, 129.6957 +7096, 66.06759, 137.8167 +7097, 68.51708, 125.1696 +7098, 64.11949, 112.7134 +7099, 66.96134, 122.761 +7100, 67.96643, 118.005 +7101, 67.0344, 143.2701 +7102, 70.02335, 122.6553 +7103, 68.2267, 139.9412 +7104, 68.92581, 110.0091 +7105, 66.98588, 136.5209 +7106, 66.60277, 126.6768 +7107, 71.395, 133.8678 +7108, 67.86413, 136.4188 +7109, 69.13237, 126.8823 +7110, 67.87654, 117.7937 +7111, 68.76083, 132.8404 +7112, 67.36789, 116.0168 +7113, 65.16072, 135.585 +7114, 70.55072, 125.9307 +7115, 66.4049, 121.0867 +7116, 66.83446, 136.2764 +7117, 67.26086, 120.1009 +7118, 70.00579, 133.7637 +7119, 70.13397, 138.0896 +7120, 67.04961, 127.2923 +7121, 67.13933, 116.9931 +7122, 68.39594, 143.1639 +7123, 67.26621, 138.2081 +7124, 70.70541, 140.5597 +7125, 64.81425, 117.1367 +7126, 67.63186, 134.8175 +7127, 63.99001, 130.4298 +7128, 67.89236, 120.5148 +7129, 65.72178, 118.9157 +7130, 67.34324, 124.2062 +7131, 71.7701, 143.3808 +7132, 65.51898, 102.0683 +7133, 67.25056, 120.3717 +7134, 68.26108, 134.7602 +7135, 67.88764, 133.5285 +7136, 69.86454, 151.4865 +7137, 68.69896, 125.0424 +7138, 70.16294, 133.275 +7139, 64.9089, 114.8393 +7140, 69.99566, 136.6724 +7141, 66.28872, 124.6184 +7142, 71.21582, 153.9191 +7143, 67.42305, 130.0958 +7144, 68.73146, 126.8497 +7145, 67.73615, 130.1305 +7146, 68.15963, 137.0062 +7147, 69.62686, 143.488 +7148, 68.1477, 139.4233 +7149, 67.65882, 111.2477 +7150, 64.6576, 115.7454 +7151, 71.4186, 152.3875 +7152, 66.99874, 101.7823 +7153, 70.37822, 138.2295 +7154, 66.51704, 144.9564 +7155, 67.18007, 126.0652 +7156, 68.03524, 129.5533 +7157, 63.49286, 100.8383 +7158, 67.48731, 135.685 +7159, 68.98253, 130.124 +7160, 68.48716, 114.3281 +7161, 68.43382, 119.7082 +7162, 66.82633, 117.9674 +7163, 68.58959, 136.604 +7164, 68.21922, 126.5181 +7165, 68.79074, 139.2679 +7166, 66.59109, 132.4449 +7167, 65.72831, 129.9469 +7168, 69.45052, 105.7793 +7169, 67.07052, 120.3329 +7170, 66.06131, 110.5079 +7171, 64.13507, 122.0272 +7172, 65.8497, 121.6887 +7173, 68.81954, 140.3287 +7174, 68.01948, 130.2994 +7175, 66.17253, 130.1025 +7176, 69.20803, 133.1917 +7177, 69.09409, 128.1301 +7178, 69.50502, 137.3243 +7179, 69.27992, 139.0344 +7180, 69.8233, 152.5737 +7181, 69.33597, 145.3588 +7182, 69.64967, 131.4688 +7183, 68.92694, 135.01 +7184, 67.99845, 120.3701 +7185, 66.80329, 131.1969 +7186, 64.69195, 116.3957 +7187, 69.49096, 133.2719 +7188, 68.30048, 114.0233 +7189, 65.80058, 110.1396 +7190, 69.8954, 127.7667 +7191, 68.42628, 122.4339 +7192, 69.50113, 130.9145 +7193, 69.29251, 143.7263 +7194, 67.7469, 140.5105 +7195, 68.04911, 117.309 +7196, 69.58269, 128.3045 +7197, 66.98591, 132.42 +7198, 70.06189, 151.3699 +7199, 67.95494, 103.0898 +7200, 69.72035, 135.2409 +7201, 67.76978, 125.5754 +7202, 71.50252, 134.2854 +7203, 66.8927, 116.1475 +7204, 69.78987, 145.157 +7205, 69.18094, 97.38482 +7206, 69.55195, 141.5296 +7207, 66.76773, 124.1834 +7208, 70.68901, 119.41 +7209, 67.44662, 110.9564 +7210, 70.43882, 152.882 +7211, 69.38655, 133.4961 +7212, 67.25475, 131.5363 +7213, 70.51274, 147.9493 +7214, 68.07194, 107.2294 +7215, 66.82279, 123.3618 +7216, 72.79602, 119.6208 +7217, 66.80265, 109.7922 +7218, 68.40038, 130.909 +7219, 66.53305, 135.1808 +7220, 66.19168, 110.6117 +7221, 70.86937, 145.8197 +7222, 67.03655, 118.0754 +7223, 70.32482, 136.9369 +7224, 63.52966, 111.5511 +7225, 65.38477, 125.863 +7226, 67.61447, 126.7202 +7227, 69.8557, 157.414 +7228, 64.02049, 108.3825 +7229, 64.67575, 112.1651 +7230, 67.23841, 118.3111 +7231, 65.11543, 108.6568 +7232, 66.20656, 119.9807 +7233, 69.70118, 126.3537 +7234, 70.47463, 119.7988 +7235, 68.64678, 126.5725 +7236, 67.34344, 119.4016 +7237, 65.62668, 120.6734 +7238, 66.96462, 122.5543 +7239, 68.23983, 119.0203 +7240, 69.3839, 126.4594 +7241, 66.51058, 112.3129 +7242, 66.37135, 118.6985 +7243, 71.9533, 132.4024 +7244, 70.8278, 136.0832 +7245, 69.65515, 129.2316 +7246, 67.97516, 137.9614 +7247, 67.6667, 131.5778 +7248, 69.76989, 141.3806 +7249, 68.36656, 134.1194 +7250, 68.80647, 118.5526 +7251, 67.12544, 116.3449 +7252, 68.11498, 136.6981 +7253, 67.29381, 131.0281 +7254, 70.70649, 112.1012 +7255, 65.08928, 131.0829 +7256, 71.1406, 127.4022 +7257, 70.56025, 150.4959 +7258, 68.47391, 130.8527 +7259, 68.99078, 147.5658 +7260, 70.76446, 128.8298 +7261, 69.76717, 131.0973 +7262, 65.74663, 118.725 +7263, 66.98775, 143.9424 +7264, 64.41271, 112.5632 +7265, 67.19909, 125.5583 +7266, 67.00659, 136.9352 +7267, 67.64628, 132.7607 +7268, 67.50257, 142.7019 +7269, 67.6803, 139.2383 +7270, 73.81695, 140.0915 +7271, 64.48825, 134.3808 +7272, 64.58578, 120.986 +7273, 66.58703, 114.208 +7274, 68.7568, 128.8771 +7275, 67.84196, 127.669 +7276, 69.0289, 129.4355 +7277, 70.24106, 122.759 +7278, 66.48991, 126.8856 +7279, 69.47393, 132.2408 +7280, 66.15579, 132.3362 +7281, 66.50286, 137.7408 +7282, 71.5695, 148.1165 +7283, 67.4536, 119.7771 +7284, 65.97892, 122.5452 +7285, 68.36647, 147.1068 +7286, 67.64033, 142.18 +7287, 68.45333, 134.8398 +7288, 67.641, 131.9221 +7289, 65.33383, 135.0619 +7290, 71.61624, 140.3879 +7291, 69.96497, 144.7957 +7292, 70.31945, 133.4026 +7293, 68.04474, 134.0615 +7294, 70.72336, 140.8089 +7295, 68.49315, 136.7987 +7296, 67.94018, 117.5218 +7297, 66.67637, 125.0994 +7298, 66.33467, 120.3094 +7299, 68.4344, 131.5393 +7300, 66.06591, 128.7348 +7301, 68.27948, 145.317 +7302, 71.13503, 139.9063 +7303, 65.90755, 111.1929 +7304, 66.34423, 134.0435 +7305, 65.3504, 109.4509 +7306, 66.77512, 125.6017 +7307, 70.15968, 125.4635 +7308, 64.87603, 108.8633 +7309, 66.39882, 122.1298 +7310, 70.19458, 134.7721 +7311, 65.14868, 118.2586 +7312, 69.13566, 134.8389 +7313, 68.66753, 149.9199 +7314, 68.58656, 120.5065 +7315, 68.54078, 131.3163 +7316, 69.04324, 120.7318 +7317, 67.79093, 145.3154 +7318, 70.54534, 128.9349 +7319, 67.88231, 132.4517 +7320, 66.60399, 125.7715 +7321, 65.36397, 88.81051 +7322, 69.68018, 138.3541 +7323, 68.57678, 127.8418 +7324, 66.22321, 127.7406 +7325, 68.5423, 117.28 +7326, 67.7995, 133.4251 +7327, 68.63948, 140.4405 +7328, 67.95206, 131.4384 +7329, 67.73545, 111.3263 +7330, 67.6113, 115.9311 +7331, 70.69283, 141.2872 +7332, 68.26736, 129.9806 +7333, 65.89008, 134.8798 +7334, 73.01042, 156.0944 +7335, 67.67587, 134.7738 +7336, 66.78503, 135.5158 +7337, 68.32888, 120.9929 +7338, 70.73417, 133.0843 +7339, 69.43571, 128.0102 +7340, 69.95298, 111.8821 +7341, 68.38192, 108.5709 +7342, 66.70985, 141.8568 +7343, 70.25069, 134.9127 +7344, 67.62069, 118.2398 +7345, 67.58186, 123.5611 +7346, 65.98681, 110.9755 +7347, 68.78521, 121.7078 +7348, 68.62075, 128.9687 +7349, 67.27841, 132.6356 +7350, 65.34695, 111.0262 +7351, 69.76109, 143.2576 +7352, 69.89052, 125.2298 +7353, 69.03762, 136.3245 +7354, 67.52712, 126.3744 +7355, 69.42798, 133.2845 +7356, 69.25325, 122.813 +7357, 67.20804, 121.3649 +7358, 68.00991, 139.8288 +7359, 72.35641, 130.8996 +7360, 65.18365, 137.4973 +7361, 67.18597, 124.8715 +7362, 67.76811, 122.6361 +7363, 69.67532, 128.1323 +7364, 68.04481, 110.4944 +7365, 70.36942, 130.4623 +7366, 64.41718, 124.1877 +7367, 66.85948, 140.3651 +7368, 70.20287, 132.4583 +7369, 67.02928, 129.9706 +7370, 69.26978, 144.3226 +7371, 67.42833, 118.4512 +7372, 70.54165, 133.0559 +7373, 64.53151, 123.7602 +7374, 68.24766, 125.6892 +7375, 65.98542, 129.7971 +7376, 66.86053, 106.1024 +7377, 66.122, 139.3225 +7378, 67.34277, 130.4799 +7379, 67.62678, 119.9616 +7380, 67.02834, 124.4751 +7381, 67.42969, 126.0978 +7382, 66.99899, 128.2102 +7383, 69.26638, 136.238 +7384, 67.67848, 121.8698 +7385, 68.48995, 112.3066 +7386, 69.15514, 134.703 +7387, 69.54796, 127.4389 +7388, 67.40434, 106.6406 +7389, 66.14023, 107.8906 +7390, 63.61758, 117.2843 +7391, 65.16034, 110.2457 +7392, 68.08398, 121.0482 +7393, 67.93785, 124.3501 +7394, 67.52815, 128.1553 +7395, 68.97399, 121.222 +7396, 63.48592, 121.0895 +7397, 66.16304, 117.5089 +7398, 64.82835, 97.5369 +7399, 66.42971, 119.6172 +7400, 68.43495, 118.9727 +7401, 66.52114, 137.8509 +7402, 68.74805, 121.5155 +7403, 65.97323, 132.5458 +7404, 67.03314, 100.0056 +7405, 68.58693, 141.2024 +7406, 66.32704, 126.5394 +7407, 72.83685, 155.3977 +7408, 70.3984, 134.7797 +7409, 68.05803, 125.6942 +7410, 65.14364, 115.004 +7411, 69.14854, 125.904 +7412, 64.25558, 123.25 +7413, 63.75162, 117.198 +7414, 72.02677, 148.7849 +7415, 65.65417, 128.8653 +7416, 67.21431, 118.7941 +7417, 69.10937, 123.3988 +7418, 64.55084, 90.03145 +7419, 69.84948, 120.5746 +7420, 70.64157, 126.2191 +7421, 67.02268, 126.7902 +7422, 66.05177, 124.9625 +7423, 67.36082, 143.185 +7424, 67.63802, 129.4889 +7425, 67.75642, 131.3101 +7426, 69.01775, 139.614 +7427, 66.81603, 120.3352 +7428, 68.1264, 128.0491 +7429, 69.39699, 144.2164 +7430, 68.0198, 107.2461 +7431, 71.13762, 140.6199 +7432, 66.92045, 110.6346 +7433, 68.51978, 123.7867 +7434, 67.49444, 134.2646 +7435, 67.69485, 135.7343 +7436, 70.48607, 132.574 +7437, 64.47721, 101.3696 +7438, 69.08046, 138.2492 +7439, 67.60168, 131.9158 +7440, 68.3217, 99.18847 +7441, 68.73792, 104.5348 +7442, 65.82668, 108.8067 +7443, 67.5949, 129.1996 +7444, 69.82714, 132.2253 +7445, 69.24298, 132.0935 +7446, 66.8406, 121.3455 +7447, 69.53579, 120.1047 +7448, 66.37498, 122.0791 +7449, 66.07098, 125.3647 +7450, 64.61507, 112.5542 +7451, 68.42049, 121.1324 +7452, 69.56459, 115.4338 +7453, 69.39142, 140.7167 +7454, 68.43529, 123.0205 +7455, 67.05497, 127.0142 +7456, 67.7922, 130.0494 +7457, 71.94893, 144.1957 +7458, 69.63726, 129.699 +7459, 72.0813, 143.083 +7460, 68.45988, 117.2453 +7461, 65.46367, 139.3682 +7462, 67.27282, 106.0456 +7463, 68.18818, 131.0038 +7464, 67.28198, 119.6203 +7465, 63.91125, 112.35 +7466, 67.71167, 132.679 +7467, 72.1432, 139.7611 +7468, 68.25521, 135.8145 +7469, 67.53778, 133.3183 +7470, 68.60468, 121.2002 +7471, 67.59235, 111.6109 +7472, 65.19918, 114.0807 +7473, 62.40921, 110.2593 +7474, 70.58047, 122.8997 +7475, 68.8901, 134.8572 +7476, 68.74666, 119.1949 +7477, 66.29907, 118.4403 +7478, 66.65775, 134.1269 +7479, 66.55058, 125.0959 +7480, 67.70659, 123.8787 +7481, 69.75302, 125.8733 +7482, 67.72124, 114.2514 +7483, 69.36439, 135.5384 +7484, 66.44274, 115.7687 +7485, 67.19566, 119.574 +7486, 66.4343, 114.6366 +7487, 65.08244, 117.4341 +7488, 70.47208, 153.8939 +7489, 67.66172, 107.8835 +7490, 67.5012, 113.0245 +7491, 68.91253, 131.5965 +7492, 67.64257, 131.1377 +7493, 68.50697, 139.4594 +7494, 67.21841, 133.7691 +7495, 65.88687, 113.0185 +7496, 69.8779, 118.3424 +7497, 70.37038, 138.2626 +7498, 68.66927, 139.6973 +7499, 68.70197, 132.6589 +7500, 69.8006, 141.7412 +7501, 70.90949, 150.0568 +7502, 65.1748, 118.2564 +7503, 66.21658, 118.9631 +7504, 69.61605, 135.4832 +7505, 69.87508, 154.3167 +7506, 65.58734, 133.1199 +7507, 66.083, 115.4637 +7508, 70.48212, 135.9939 +7509, 67.84056, 112.9479 +7510, 68.47217, 136.3002 +7511, 66.79221, 128.7134 +7512, 68.54694, 124.5508 +7513, 64.80177, 114.0726 +7514, 66.60203, 106.2728 +7515, 67.21014, 121.7322 +7516, 66.73678, 114.8589 +7517, 66.53306, 110.7923 +7518, 68.6929, 132.2393 +7519, 68.19062, 141.1859 +7520, 63.92606, 121.3297 +7521, 69.5829, 117.6169 +7522, 70.98816, 140.1896 +7523, 70.76388, 141.9068 +7524, 65.02684, 126.1456 +7525, 66.90201, 128.0042 +7526, 69.23204, 130.8349 +7527, 66.09344, 143.7256 +7528, 69.49427, 138.9172 +7529, 68.05, 140.3419 +7530, 67.49402, 131.6908 +7531, 68.85025, 140.8144 +7532, 68.23896, 125.7072 +7533, 68.38393, 116.0417 +7534, 68.95408, 113.6366 +7535, 67.65103, 125.5184 +7536, 66.20531, 111.8929 +7537, 68.93726, 134.5124 +7538, 67.80014, 127.1 +7539, 65.2647, 121.8737 +7540, 68.09232, 130.421 +7541, 68.65955, 115.7811 +7542, 67.81543, 120.4567 +7543, 65.20035, 133.6623 +7544, 65.84472, 105.3131 +7545, 67.38545, 141.2867 +7546, 67.92876, 124.5046 +7547, 66.27859, 120.0427 +7548, 70.74889, 121.0602 +7549, 69.97731, 147.2286 +7550, 67.20964, 125.5631 +7551, 67.31481, 126.7142 +7552, 70.24038, 147.5274 +7553, 68.99325, 134.3203 +7554, 68.59389, 131.2151 +7555, 67.98396, 137.5212 +7556, 70.36114, 149.4448 +7557, 68.91001, 125.7485 +7558, 66.87767, 123.1591 +7559, 66.79704, 122.6614 +7560, 66.1317, 107.0973 +7561, 72.32421, 126.4469 +7562, 68.51105, 130.1897 +7563, 68.79547, 128.0733 +7564, 70.50895, 147.6337 +7565, 67.21348, 124.8905 +7566, 67.40794, 140.4072 +7567, 67.35628, 135.5266 +7568, 68.38489, 129.793 +7569, 71.91894, 140.7337 +7570, 68.43062, 121.2177 +7571, 67.77666, 139.6088 +7572, 68.99119, 117.0843 +7573, 66.21266, 129.6054 +7574, 67.7385, 123.8408 +7575, 70.30638, 129.3636 +7576, 68.12954, 118.034 +7577, 69.86354, 127.871 +7578, 68.46795, 129.2263 +7579, 70.82723, 130.3162 +7580, 70.53312, 125.3443 +7581, 66.68491, 114.5746 +7582, 67.9728, 123.6368 +7583, 67.22708, 111.5203 +7584, 69.68289, 135.3127 +7585, 66.59604, 126.2811 +7586, 66.10015, 128.3855 +7587, 67.86074, 110.5005 +7588, 68.01097, 125.1627 +7589, 67.5839, 131.7113 +7590, 67.5159, 129.2797 +7591, 68.53632, 127.2682 +7592, 65.53007, 116.1557 +7593, 67.01862, 115.6411 +7594, 71.70261, 130.089 +7595, 67.42779, 119.1357 +7596, 67.40744, 138.6263 +7597, 70.61318, 132.1391 +7598, 71.40194, 133.7259 +7599, 64.09089, 103.413 +7600, 68.57917, 140.5224 +7601, 70.44562, 139.2476 +7602, 68.78892, 137.1816 +7603, 68.17666, 128.6937 +7604, 67.25766, 119.6812 +7605, 69.58706, 134.283 +7606, 65.62971, 117.5826 +7607, 70.16689, 149.014 +7608, 66.6029, 125.2519 +7609, 66.8357, 137.9874 +7610, 67.74481, 114.0989 +7611, 67.01471, 105.5528 +7612, 68.82323, 129.1214 +7613, 66.53189, 121.6671 +7614, 64.95852, 125.6806 +7615, 66.39552, 106.5133 +7616, 69.15387, 145.4679 +7617, 67.3919, 137.8311 +7618, 66.46185, 108.3132 +7619, 66.04052, 117.8311 +7620, 70.38614, 137.0213 +7621, 65.65727, 94.93893 +7622, 67.33538, 121.7877 +7623, 69.28239, 127.8304 +7624, 70.2126, 136.728 +7625, 64.3484, 113.3811 +7626, 69.31893, 139.7068 +7627, 71.18364, 137.8162 +7628, 66.69679, 104.8015 +7629, 69.94556, 129.3583 +7630, 66.51505, 138.6321 +7631, 64.14991, 116.5963 +7632, 69.92795, 124.8835 +7633, 66.73025, 137.4516 +7634, 68.51984, 140.2377 +7635, 67.32388, 136.2189 +7636, 64.05124, 104.3901 +7637, 68.15534, 119.4984 +7638, 67.71709, 118.2663 +7639, 66.70415, 130.1457 +7640, 67.41672, 129.0666 +7641, 68.76344, 132.7511 +7642, 67.84973, 117.4982 +7643, 67.26853, 130.8403 +7644, 68.45943, 125.5251 +7645, 67.22402, 115.863 +7646, 66.8748, 128.8302 +7647, 66.74881, 109.3304 +7648, 69.44453, 125.8588 +7649, 65.4609, 107.2491 +7650, 68.67207, 125.2769 +7651, 69.85604, 129.2856 +7652, 69.12214, 122.2752 +7653, 69.21372, 130.3915 +7654, 67.02625, 132.8653 +7655, 67.69648, 130.4108 +7656, 70.06564, 154.3757 +7657, 69.36177, 137.7144 +7658, 69.0855, 123.928 +7659, 68.21874, 127.1621 +7660, 68.60997, 126.3357 +7661, 66.55127, 114.9381 +7662, 68.71959, 118.2746 +7663, 68.58571, 122.5043 +7664, 69.08825, 120.3915 +7665, 66.85375, 98.47908 +7666, 68.56317, 131.2951 +7667, 66.72783, 116.8011 +7668, 66.73504, 131.919 +7669, 68.65369, 118.3939 +7670, 66.11318, 120.0249 +7671, 66.7098, 126.7391 +7672, 67.44065, 152.5009 +7673, 69.25731, 120.6596 +7674, 68.75465, 130.2 +7675, 70.94505, 138.8221 +7676, 67.77684, 136.6213 +7677, 66.24745, 105.4542 +7678, 62.64956, 130.3208 +7679, 67.42044, 129.5017 +7680, 64.44748, 112.1223 +7681, 67.88848, 107.7735 +7682, 70.5403, 142.2364 +7683, 70.31573, 130.1736 +7684, 67.8145, 133.648 +7685, 64.61064, 106.9745 +7686, 68.75828, 127.1369 +7687, 70.67508, 141.6155 +7688, 64.79201, 123.8881 +7689, 67.22238, 124.7274 +7690, 66.7514, 133.492 +7691, 69.90536, 140.1252 +7692, 71.96265, 135.2445 +7693, 65.42972, 129.5831 +7694, 66.60135, 120.7322 +7695, 66.4318, 133.7433 +7696, 66.34089, 104.3528 +7697, 69.96979, 140.0099 +7698, 71.64134, 120.8264 +7699, 66.24195, 115.9752 +7700, 68.69749, 117.0558 +7701, 67.15067, 129.4873 +7702, 71.9673, 133.6015 +7703, 68.5542, 126.6594 +7704, 67.05171, 122.6178 +7705, 67.50469, 132.9071 +7706, 68.78436, 125.2964 +7707, 67.07846, 114.7138 +7708, 65.46411, 131.4842 +7709, 69.49787, 123.4755 +7710, 64.67323, 120.1682 +7711, 69.32483, 134.088 +7712, 64.39847, 121.9653 +7713, 67.9694, 103.3546 +7714, 68.17004, 112.4828 +7715, 66.87249, 105.3961 +7716, 67.30874, 135.062 +7717, 68.26251, 132.1296 +7718, 65.36754, 127.2412 +7719, 68.94823, 125.0147 +7720, 67.50617, 113.585 +7721, 64.29247, 120.1023 +7722, 65.5634, 129.7442 +7723, 68.65306, 128.7635 +7724, 67.66637, 104.2348 +7725, 66.46271, 125.962 +7726, 69.61949, 138.3373 +7727, 70.151, 144.0366 +7728, 68.00747, 137.1058 +7729, 68.85235, 130.6387 +7730, 70.34804, 124.7815 +7731, 65.0196, 134.4502 +7732, 67.58782, 132.8462 +7733, 67.96341, 135.425 +7734, 64.23356, 124.1334 +7735, 71.82677, 143.9272 +7736, 68.40776, 124.9954 +7737, 72.92705, 155.452 +7738, 68.2634, 124.8133 +7739, 71.32032, 128.3211 +7740, 69.04566, 142.9052 +7741, 65.18871, 115.9 +7742, 66.94576, 121.9962 +7743, 69.21635, 136.23 +7744, 65.53434, 120.8577 +7745, 64.91416, 107.684 +7746, 66.40921, 104.361 +7747, 66.51021, 130.011 +7748, 68.98924, 127.6238 +7749, 70.39002, 142.0184 +7750, 67.27302, 134.5354 +7751, 68.27392, 124.1453 +7752, 66.13665, 125.066 +7753, 69.8415, 138.2726 +7754, 69.24298, 125.4025 +7755, 69.49259, 107.8487 +7756, 68.01659, 138.7248 +7757, 67.14071, 126.4965 +7758, 67.32799, 122.5994 +7759, 67.22067, 117.1647 +7760, 67.2075, 122.9325 +7761, 71.22072, 133.3385 +7762, 62.61388, 127.7046 +7763, 66.05642, 112.4733 +7764, 68.6259, 111.0985 +7765, 66.42125, 128.5118 +7766, 67.66226, 122.9677 +7767, 67.87257, 125.7629 +7768, 69.43314, 142.9565 +7769, 66.91873, 108.1239 +7770, 67.0773, 131.3885 +7771, 66.38627, 123.3667 +7772, 66.88154, 118.5143 +7773, 70.13999, 135.2062 +7774, 65.0467, 129.3282 +7775, 67.94255, 147.0635 +7776, 65.69521, 126.7902 +7777, 65.69631, 123.84 +7778, 68.06505, 118.6554 +7779, 65.57689, 127.0804 +7780, 69.51367, 137.4305 +7781, 68.01036, 132.4546 +7782, 65.97185, 113.2777 +7783, 68.50408, 117.6372 +7784, 68.6578, 125.8654 +7785, 64.90631, 128.857 +7786, 66.86878, 121.5519 +7787, 67.45601, 101.7983 +7788, 70.57507, 136.4959 +7789, 65.50493, 113.2549 +7790, 68.03809, 139.6333 +7791, 70.44638, 132.7411 +7792, 66.83931, 111.3947 +7793, 66.38356, 102.0057 +7794, 68.33698, 124.0644 +7795, 69.41356, 137.8685 +7796, 67.82728, 134.7202 +7797, 69.1966, 139.0328 +7798, 66.58126, 118.1128 +7799, 65.86804, 132.2918 +7800, 67.92387, 127.8828 +7801, 67.65969, 114.3964 +7802, 69.00849, 135.8661 +7803, 68.02905, 110.9974 +7804, 67.90776, 113.0832 +7805, 67.89813, 102.687 +7806, 70.78714, 159.3967 +7807, 66.32968, 129.7132 +7808, 71.20406, 141.4122 +7809, 67.87705, 129.9013 +7810, 65.94546, 116.2096 +7811, 69.87679, 126.6121 +7812, 65.79065, 114.8391 +7813, 70.22362, 130.9476 +7814, 68.85931, 117.224 +7815, 67.99466, 128.0368 +7816, 67.08757, 129.2199 +7817, 68.85889, 124.9153 +7818, 66.06887, 119.7681 +7819, 70.41331, 137.758 +7820, 68.26431, 124.0211 +7821, 70.00963, 125.9789 +7822, 65.69038, 125.507 +7823, 70.94803, 118.2146 +7824, 70.40454, 152.6344 +7825, 67.93137, 124.0016 +7826, 67.24148, 130.8507 +7827, 67.43967, 132.5789 +7828, 67.97769, 137.5606 +7829, 69.69329, 134.532 +7830, 68.88, 120.9022 +7831, 66.22857, 117.7639 +7832, 64.74463, 113.2767 +7833, 71.14304, 147.1355 +7834, 65.97479, 113.5152 +7835, 69.43298, 159.7844 +7836, 65.39464, 125.1913 +7837, 68.47642, 127.5662 +7838, 67.68893, 125.6505 +7839, 69.77827, 118.6649 +7840, 73.85521, 136.0667 +7841, 68.65677, 122.8314 +7842, 68.88401, 133.0347 +7843, 66.74014, 136.451 +7844, 68.04482, 126.3811 +7845, 64.85449, 114.2042 +7846, 67.03991, 120.3379 +7847, 65.56486, 119.8795 +7848, 68.13322, 134.1961 +7849, 65.6523, 125.6206 +7850, 72.22353, 138.8165 +7851, 67.93045, 126.3497 +7852, 70.43116, 135.7442 +7853, 68.08474, 138.0519 +7854, 69.8667, 126.1461 +7855, 68.70872, 120.9616 +7856, 68.58329, 139.8337 +7857, 66.67676, 122.2411 +7858, 69.96239, 129.7149 +7859, 66.29991, 137.1631 +7860, 65.76482, 104.5086 +7861, 69.11191, 135.7377 +7862, 66.87869, 111.5493 +7863, 67.36932, 147.7067 +7864, 69.93728, 150.4786 +7865, 69.81301, 133.0872 +7866, 66.56086, 140.7383 +7867, 70.95923, 130.441 +7868, 69.19946, 127.5606 +7869, 70.28687, 133.9221 +7870, 69.97118, 145.462 +7871, 69.9306, 133.8265 +7872, 67.23945, 126.2885 +7873, 67.2735, 117.1077 +7874, 66.48165, 128.5263 +7875, 68.44572, 120.2431 +7876, 66.89716, 114.7654 +7877, 65.29685, 132.424 +7878, 69.06524, 132.1972 +7879, 68.02311, 135.255 +7880, 70.02667, 113.9045 +7881, 65.82948, 117.297 +7882, 70.21039, 150.618 +7883, 68.55081, 143.2179 +7884, 66.17612, 132.1823 +7885, 67.36138, 134.9196 +7886, 69.98058, 122.1659 +7887, 65.49847, 122.904 +7888, 67.22664, 108.7074 +7889, 67.28114, 132.6449 +7890, 66.27424, 121.0436 +7891, 67.20346, 117.715 +7892, 69.96933, 133.341 +7893, 70.33173, 138.2921 +7894, 67.60168, 130.4579 +7895, 70.12592, 117.4415 +7896, 65.79449, 107.1855 +7897, 67.9113, 128.3023 +7898, 66.60677, 114.237 +7899, 66.36069, 116.3676 +7900, 69.37216, 124.5841 +7901, 69.08983, 131.53 +7902, 68.03826, 137.6548 +7903, 66.72346, 127.1615 +7904, 65.5982, 110.4732 +7905, 66.56595, 125.4882 +7906, 68.54091, 124.8483 +7907, 71.80497, 136.4508 +7908, 69.41584, 123.6033 +7909, 67.91457, 126.7841 +7910, 66.63057, 141.1367 +7911, 70.00844, 127.3606 +7912, 67.21345, 134.9724 +7913, 69.9974, 135.8397 +7914, 70.44321, 142.7681 +7915, 69.99219, 126.5143 +7916, 71.11277, 131.7103 +7917, 68.42954, 126.6811 +7918, 71.73402, 122.6931 +7919, 68.25089, 134.2315 +7920, 72.13361, 120.9306 +7921, 69.0911, 132.2909 +7922, 66.02501, 132.287 +7923, 65.3813, 126.1785 +7924, 67.27872, 118.2022 +7925, 68.98874, 126.4329 +7926, 68.9963, 120.3791 +7927, 66.75512, 103.6353 +7928, 66.09072, 112.3691 +7929, 68.70395, 119.6693 +7930, 64.72417, 106.3895 +7931, 69.53108, 120.2067 +7932, 71.32029, 156.5971 +7933, 69.25388, 132.4808 +7934, 70.01373, 132.0505 +7935, 72.0594, 148.9722 +7936, 68.49943, 128.9143 +7937, 67.20711, 109.9494 +7938, 67.4277, 121.8319 +7939, 67.38905, 136.4146 +7940, 68.81456, 154.4947 +7941, 65.56306, 116.8189 +7942, 68.86564, 123.4374 +7943, 67.63208, 128.5252 +7944, 63.64527, 114.5546 +7945, 69.12102, 142.8329 +7946, 70.19208, 124.5284 +7947, 68.62725, 109.5514 +7948, 68.58176, 137.4034 +7949, 66.78338, 119.4607 +7950, 67.68417, 122.7447 +7951, 68.79943, 143.4836 +7952, 66.72578, 116.2868 +7953, 67.68983, 120.3912 +7954, 67.24673, 117.8198 +7955, 70.80139, 131.9536 +7956, 69.81422, 128.8624 +7957, 67.41926, 118.315 +7958, 68.10832, 140.7132 +7959, 69.52176, 138.7414 +7960, 66.44673, 123.6693 +7961, 66.50938, 104.0396 +7962, 68.27624, 122.9904 +7963, 67.51054, 131.6367 +7964, 68.2331, 122.1745 +7965, 69.20004, 128.2344 +7966, 68.22569, 135.757 +7967, 69.67618, 116.2938 +7968, 69.15372, 134.0076 +7969, 67.44681, 127.5092 +7970, 71.4192, 145.7932 +7971, 66.01984, 141.9976 +7972, 67.5773, 127.9425 +7973, 64.49893, 140.2004 +7974, 70.19674, 126.914 +7975, 67.51149, 123.7364 +7976, 66.75836, 119.0958 +7977, 66.36645, 132.4222 +7978, 65.96947, 126.7739 +7979, 67.47588, 138.5358 +7980, 65.8521, 115.0837 +7981, 67.1238, 122.7868 +7982, 69.1103, 138.6654 +7983, 64.77536, 113.5556 +7984, 68.77562, 126.086 +7985, 69.56475, 128.952 +7986, 66.86676, 137.0564 +7987, 67.45183, 142.6514 +7988, 66.7056, 127.0386 +7989, 69.45967, 130.8347 +7990, 67.83848, 120.0967 +7991, 67.65053, 137.3509 +7992, 69.02638, 135.0166 +7993, 68.05329, 125.4398 +7994, 65.0137, 113.7752 +7995, 67.74935, 128.7894 +7996, 67.3018, 110.3175 +7997, 69.57329, 169.1268 +7998, 66.46916, 127.2647 +7999, 67.37618, 121.7823 +8000, 66.03128, 123.2914 +8001, 67.88652, 126.5258 +8002, 66.60311, 124.1856 +8003, 67.72857, 119.5459 +8004, 66.20895, 125.1912 +8005, 69.24463, 126.2716 +8006, 68.69724, 110.894 +8007, 66.70205, 120.3019 +8008, 71.16914, 135.0369 +8009, 65.43614, 152.6168 +8010, 67.25401, 130.5463 +8011, 68.05015, 123.7466 +8012, 70.48365, 134.9316 +8013, 69.03379, 129.6641 +8014, 65.4187, 118.1433 +8015, 68.94762, 136.9932 +8016, 68.75178, 107.7319 +8017, 69.54295, 135.5159 +8018, 66.34532, 123.7345 +8019, 69.9271, 146.4336 +8020, 66.65813, 127.9335 +8021, 68.55262, 123.4302 +8022, 65.96412, 122.5101 +8023, 69.48892, 119.1983 +8024, 66.3432, 137.1607 +8025, 68.28599, 123.3591 +8026, 68.39674, 126.1915 +8027, 65.75868, 111.5519 +8028, 68.36155, 133.9494 +8029, 69.21078, 134.4253 +8030, 67.22096, 114.8024 +8031, 68.65998, 124.7691 +8032, 68.44603, 110.3778 +8033, 70.35705, 125.9397 +8034, 71.52468, 137.9496 +8035, 67.94061, 141.0108 +8036, 70.04339, 127.3467 +8037, 64.54078, 130.1828 +8038, 66.18181, 127.6085 +8039, 68.11241, 124.1533 +8040, 69.5091, 151.7634 +8041, 71.46618, 135.5982 +8042, 67.79009, 131.2158 +8043, 64.8491, 121.2608 +8044, 66.50511, 137.4995 +8045, 70.0677, 144.6209 +8046, 69.80295, 116.8405 +8047, 70.14185, 131.8359 +8048, 67.22436, 133.605 +8049, 71.97836, 138.1052 +8050, 69.32003, 136.5839 +8051, 67.41409, 123.8328 +8052, 68.08026, 131.0779 +8053, 68.13257, 136.8494 +8054, 70.37547, 130.5691 +8055, 70.31686, 132.9542 +8056, 65.5543, 121.2351 +8057, 64.65127, 118.3996 +8058, 69.73363, 122.1652 +8059, 67.69405, 121.728 +8060, 70.20483, 118.4049 +8061, 64.46691, 120.621 +8062, 69.64553, 134.4838 +8063, 69.29407, 131.2404 +8064, 68.98608, 121.228 +8065, 67.32147, 110.6602 +8066, 69.65674, 134.4204 +8067, 69.91295, 148.5606 +8068, 70.938, 129.7384 +8069, 68.91523, 109.4881 +8070, 68.55359, 131.1947 +8071, 66.76524, 121.931 +8072, 70.89744, 138.8549 +8073, 73.09657, 134.9595 +8074, 69.22647, 145.0718 +8075, 63.65093, 116.5654 +8076, 66.46411, 129.734 +8077, 68.35474, 123.7944 +8078, 67.57134, 124.2097 +8079, 66.83183, 135.5006 +8080, 69.62922, 143.0166 +8081, 68.05903, 126.0365 +8082, 67.54296, 134.5517 +8083, 69.303, 116.7611 +8084, 67.38937, 128.9351 +8085, 71.45669, 134.6404 +8086, 68.49029, 128.3649 +8087, 65.84126, 125.7087 +8088, 69.25123, 133.4489 +8089, 64.51431, 103.0865 +8090, 67.82414, 127.065 +8091, 65.84897, 118.2251 +8092, 70.67116, 122.6757 +8093, 67.11351, 124.6458 +8094, 67.59487, 138.5996 +8095, 66.33295, 116.4343 +8096, 69.89298, 140.0236 +8097, 66.38557, 142.4689 +8098, 67.1027, 125.1139 +8099, 66.43884, 113.1903 +8100, 66.12177, 120.4629 +8101, 67.00531, 133.6411 +8102, 64.16307, 101.9669 +8103, 67.32597, 135.9051 +8104, 66.94272, 121.8755 +8105, 69.08751, 142.7891 +8106, 70.44232, 132.9498 +8107, 67.9102, 125.3998 +8108, 66.51569, 119.5183 +8109, 67.3862, 128.4407 +8110, 68.10423, 120.9619 +8111, 67.51842, 110.0212 +8112, 68.2832, 108.7627 +8113, 67.79292, 128.0636 +8114, 68.30939, 121.2109 +8115, 66.19976, 113.9021 +8116, 65.84849, 142.3934 +8117, 68.82083, 135.0981 +8118, 68.96333, 135.9867 +8119, 69.04066, 133.625 +8120, 64.90924, 123.5221 +8121, 64.53827, 121.1495 +8122, 71.75047, 139.379 +8123, 66.93045, 132.2175 +8124, 65.54236, 129.4864 +8125, 64.84131, 91.8085 +8126, 66.98431, 130.0474 +8127, 66.14261, 118.8111 +8128, 70.81757, 145.2176 +8129, 68.91444, 152.0833 +8130, 66.66634, 100.2743 +8131, 70.48203, 137.6556 +8132, 69.91213, 135.5083 +8133, 66.64902, 118.6405 +8134, 69.01354, 145.8844 +8135, 66.26097, 115.3104 +8136, 68.89543, 119.3074 +8137, 71.22325, 132.1547 +8138, 68.68597, 124.6849 +8139, 69.89911, 135.1557 +8140, 68.69947, 116.0361 +8141, 69.8535, 136.027 +8142, 63.44123, 112.1713 +8143, 64.11532, 133.1515 +8144, 71.75025, 132.088 +8145, 66.19729, 135.4905 +8146, 65.72997, 126.827 +8147, 72.16986, 137.5684 +8148, 66.48739, 127.293 +8149, 69.31215, 124.2118 +8150, 68.02947, 119.5556 +8151, 65.97774, 91.25752 +8152, 71.29851, 142.5115 +8153, 71.5143, 127.7847 +8154, 68.60076, 128.8566 +8155, 68.18368, 135.9276 +8156, 69.8811, 151.879 +8157, 67.93999, 132.0277 +8158, 69.80319, 123.1697 +8159, 65.19641, 117.6912 +8160, 67.8403, 127.0545 +8161, 68.50897, 137.9252 +8162, 65.14879, 115.1881 +8163, 66.95341, 120.6277 +8164, 68.25949, 136.41 +8165, 68.03615, 149.0647 +8166, 64.54579, 111.3072 +8167, 71.52318, 127.8014 +8168, 69.57994, 137.7495 +8169, 66.84427, 129.9887 +8170, 68.5828, 123.3208 +8171, 69.51119, 146.7832 +8172, 67.49702, 135.4823 +8173, 67.20475, 129.0149 +8174, 67.66461, 136.768 +8175, 70.03691, 122.5324 +8176, 68.89205, 118.0131 +8177, 68.85894, 135.317 +8178, 68.40447, 143.2456 +8179, 69.51754, 137.8977 +8180, 69.63896, 135.0191 +8181, 68.27563, 135.026 +8182, 65.59198, 122.9795 +8183, 64.35791, 120.4781 +8184, 67.63682, 135.534 +8185, 69.47515, 137.0927 +8186, 68.93408, 133.3871 +8187, 65.98502, 133.4505 +8188, 67.65672, 124.4906 +8189, 68.79529, 144.5481 +8190, 66.82439, 133.8378 +8191, 68.7321, 109.9033 +8192, 66.33945, 122.7443 +8193, 67.47277, 99.0744 +8194, 67.72698, 134.7996 +8195, 65.20132, 116.8893 +8196, 71.49103, 135.6049 +8197, 65.24026, 113.6473 +8198, 69.99307, 139.7899 +8199, 65.18268, 121.4679 +8200, 70.06241, 134.3005 +8201, 68.61652, 125.2 +8202, 68.15831, 124.9999 +8203, 63.48187, 117.5449 +8204, 71.29462, 142.6142 +8205, 70.11496, 143.9751 +8206, 68.83929, 141.5128 +8207, 70.15775, 113.8639 +8208, 69.59681, 133.7791 +8209, 65.83263, 122.5777 +8210, 71.32785, 135.4846 +8211, 68.20864, 143.309 +8212, 71.87288, 134.3715 +8213, 69.35277, 128.963 +8214, 67.94055, 142.3413 +8215, 69.71919, 138.7374 +8216, 64.67334, 113.3238 +8217, 65.33432, 118.6681 +8218, 67.46316, 144.152 +8219, 71.08038, 155.0439 +8220, 66.66043, 135.3184 +8221, 67.7645, 109.9437 +8222, 67.23122, 124.4395 +8223, 67.43133, 134.417 +8224, 69.74968, 130.7336 +8225, 68.14016, 128.6113 +8226, 68.9402, 133.3423 +8227, 69.35342, 136.4262 +8228, 69.8643, 140.5089 +8229, 69.31822, 136.0998 +8230, 65.9301, 105.284 +8231, 68.42378, 127.227 +8232, 65.94139, 120.6136 +8233, 68.18063, 115.003 +8234, 70.25983, 129.9544 +8235, 66.05596, 104.3081 +8236, 67.73703, 131.4725 +8237, 65.29545, 126.3612 +8238, 68.16479, 121.2363 +8239, 68.95501, 140.2805 +8240, 68.19061, 129.2682 +8241, 69.5707, 126.2858 +8242, 70.02356, 137.4431 +8243, 69.14845, 117.2798 +8244, 70.24309, 121.0725 +8245, 70.66018, 142.7478 +8246, 67.45148, 125.9385 +8247, 65.03584, 114.225 +8248, 70.45839, 133.1533 +8249, 67.11299, 120.7303 +8250, 68.24423, 137.3349 +8251, 66.7588, 105.3169 +8252, 68.7307, 116.3236 +8253, 63.45132, 118.147 +8254, 69.32305, 133.6457 +8255, 69.07258, 123.9537 +8256, 70.51044, 143.4905 +8257, 67.29369, 117.9183 +8258, 69.33952, 142.08 +8259, 67.33993, 136.4499 +8260, 66.34535, 120.6503 +8261, 64.39297, 125.5261 +8262, 66.67639, 113.1137 +8263, 72.36601, 134.7475 +8264, 68.24893, 111.0142 +8265, 65.53245, 122.3297 +8266, 67.60693, 130.4762 +8267, 68.68598, 124.5562 +8268, 68.61117, 129.6617 +8269, 70.92173, 141.8458 +8270, 69.31458, 123.953 +8271, 68.56604, 130.441 +8272, 68.63936, 127.0952 +8273, 66.36369, 136.0598 +8274, 68.99555, 114.0398 +8275, 67.46519, 122.2341 +8276, 67.80467, 123.7772 +8277, 71.52782, 116.7279 +8278, 72.49367, 154.5031 +8279, 66.60755, 123.1233 +8280, 71.07038, 138.9521 +8281, 66.33447, 150.3119 +8282, 71.17232, 129.6463 +8283, 69.03651, 138.4825 +8284, 69.34919, 137.7115 +8285, 68.05366, 126.4259 +8286, 71.4948, 132.8622 +8287, 69.06112, 115.3726 +8288, 68.23732, 110.6226 +8289, 67.93276, 120.392 +8290, 68.55485, 130.1554 +8291, 67.5741, 125.7973 +8292, 66.36239, 117.4231 +8293, 70.76127, 133.7229 +8294, 67.10716, 131.2588 +8295, 64.5143, 127.8143 +8296, 67.47838, 120.9216 +8297, 67.23335, 141.0636 +8298, 67.99254, 144.1656 +8299, 67.458, 121.6819 +8300, 66.80866, 121.3264 +8301, 66.09963, 124.8608 +8302, 66.12053, 124.1474 +8303, 64.70924, 130.2642 +8304, 69.01541, 119.7938 +8305, 67.46277, 137.7862 +8306, 71.60898, 137.8791 +8307, 69.08877, 130.997 +8308, 67.81669, 115.8327 +8309, 70.74181, 128.5074 +8310, 64.4356, 119.3601 +8311, 70.81481, 139.7362 +8312, 64.90712, 129.5891 +8313, 68.30316, 126.8148 +8314, 68.41201, 132.9198 +8315, 66.35212, 99.69835 +8316, 67.27049, 124.5827 +8317, 66.63726, 120.3137 +8318, 65.00921, 84.26295 +8319, 67.69319, 124.4028 +8320, 70.26676, 128.8174 +8321, 66.19211, 121.0948 +8322, 65.62693, 126.6962 +8323, 71.58993, 135.744 +8324, 68.54869, 108.706 +8325, 68.52266, 122.0975 +8326, 66.21562, 109.3178 +8327, 65.71102, 113.8038 +8328, 72.23909, 159.4608 +8329, 66.533, 139.0226 +8330, 67.42805, 125.9181 +8331, 64.33729, 123.4824 +8332, 68.29721, 140.0057 +8333, 69.15487, 128.4365 +8334, 69.50939, 132.4955 +8335, 65.75398, 112.9736 +8336, 67.22359, 155.7617 +8337, 66.0023, 116.0386 +8338, 67.83406, 115.5906 +8339, 71.42677, 138.3516 +8340, 68.93168, 112.8601 +8341, 68.26056, 133.5413 +8342, 65.24947, 112.2883 +8343, 66.60071, 137.7297 +8344, 69.48187, 122.6836 +8345, 66.24301, 108.3135 +8346, 65.05662, 139.3953 +8347, 69.89977, 119.9003 +8348, 69.30058, 149.1915 +8349, 72.0775, 127.4068 +8350, 65.99698, 118.3092 +8351, 68.87245, 135.0451 +8352, 68.64611, 120.4317 +8353, 67.65677, 131.041 +8354, 69.15197, 128.0926 +8355, 70.05894, 141.614 +8356, 71.40809, 135.1406 +8357, 69.03498, 147.5304 +8358, 66.53406, 104.5216 +8359, 67.71834, 124.1642 +8360, 67.63519, 130.3102 +8361, 66.43601, 120.5525 +8362, 68.15413, 117.8028 +8363, 68.81782, 124.0657 +8364, 70.69194, 140.2734 +8365, 66.05342, 124.0408 +8366, 72.41769, 143.68 +8367, 66.93146, 117.7358 +8368, 65.53734, 118.2815 +8369, 67.54175, 127.8454 +8370, 67.76318, 136.177 +8371, 66.14528, 113.1378 +8372, 66.70349, 117.5526 +8373, 65.09221, 133.8826 +8374, 68.49307, 131.2102 +8375, 65.16644, 94.21964 +8376, 67.50707, 127.7961 +8377, 65.76724, 100.2388 +8378, 67.14094, 124.5368 +8379, 67.34801, 139.8293 +8380, 68.64599, 129.0105 +8381, 69.94177, 125.379 +8382, 67.30477, 123.9033 +8383, 68.78142, 147.1507 +8384, 66.12327, 113.5479 +8385, 66.30368, 117.2405 +8386, 69.18567, 128.0275 +8387, 66.90853, 118.8067 +8388, 68.70313, 124.6767 +8389, 71.08677, 148.1246 +8390, 65.52597, 122.9936 +8391, 66.20537, 116.068 +8392, 66.6718, 107.6202 +8393, 68.72702, 137.0353 +8394, 66.7039, 120.6447 +8395, 64.89628, 118.8854 +8396, 68.21209, 129.5464 +8397, 70.50017, 134.0139 +8398, 66.65252, 127.2599 +8399, 68.51303, 135.6923 +8400, 68.45497, 142.98 +8401, 68.61334, 110.3751 +8402, 67.78067, 116.6516 +8403, 68.61734, 130.0152 +8404, 70.42853, 142.6604 +8405, 65.45001, 108.0995 +8406, 70.69777, 119.4805 +8407, 67.28034, 111.5318 +8408, 66.4768, 129.6186 +8409, 65.08921, 125.0064 +8410, 66.56312, 119.046 +8411, 65.84797, 129.5537 +8412, 69.45763, 133.2109 +8413, 70.28788, 144.2612 +8414, 65.38017, 131.5842 +8415, 66.49187, 90.16983 +8416, 67.43263, 135.136 +8417, 68.81347, 125.0421 +8418, 62.92771, 95.73883 +8419, 69.3757, 135.4546 +8420, 64.73432, 112.0029 +8421, 68.97699, 143.0838 +8422, 69.37021, 133.1309 +8423, 65.63449, 110.4167 +8424, 68.33529, 129.8376 +8425, 65.0522, 122.3385 +8426, 68.70485, 122.1685 +8427, 66.64719, 150.0087 +8428, 67.91847, 135.8583 +8429, 64.00018, 128.5779 +8430, 68.90973, 127.6864 +8431, 67.83403, 116.6157 +8432, 72.14918, 161.6214 +8433, 65.93135, 119.386 +8434, 66.35334, 121.8461 +8435, 68.14895, 130.6059 +8436, 65.85562, 124.2612 +8437, 65.85908, 126.2855 +8438, 67.61041, 111.3166 +8439, 67.74703, 131.1387 +8440, 67.43873, 118.814 +8441, 68.20254, 130.0191 +8442, 67.42837, 127.2159 +8443, 69.06903, 140.8074 +8444, 67.77306, 138.4305 +8445, 67.11898, 129.8077 +8446, 69.69668, 141.0015 +8447, 62.6775, 102.6498 +8448, 67.26069, 130.2661 +8449, 70.02024, 140.0166 +8450, 67.30077, 134.2776 +8451, 69.78242, 144.6739 +8452, 68.96031, 123.3616 +8453, 68.86806, 129.4534 +8454, 67.56025, 110.1402 +8455, 65.08546, 130.6182 +8456, 67.17754, 117.2168 +8457, 69.77675, 125.558 +8458, 69.57213, 137.4401 +8459, 69.81071, 132.9983 +8460, 69.44528, 112.1204 +8461, 69.4941, 140.3979 +8462, 67.71518, 133.3581 +8463, 71.37261, 123.5644 +8464, 67.94484, 111.4393 +8465, 71.28888, 134.7116 +8466, 68.26826, 128.6627 +8467, 68.89648, 127.3814 +8468, 67.72198, 123.9987 +8469, 69.5539, 126.974 +8470, 65.2832, 130.2877 +8471, 65.05616, 118.9465 +8472, 69.57506, 125.9928 +8473, 73.95409, 145.2695 +8474, 64.67156, 131.8694 +8475, 67.41711, 135.8198 +8476, 72.83837, 143.4551 +8477, 66.35943, 147.1762 +8478, 70.21614, 134.6977 +8479, 67.76837, 135.6669 +8480, 68.21712, 123.9896 +8481, 70.10091, 140.0683 +8482, 67.59479, 118.0146 +8483, 70.12489, 132.4516 +8484, 64.55975, 128.829 +8485, 69.18894, 142.5893 +8486, 64.18631, 108.3347 +8487, 67.82633, 139.2589 +8488, 67.78211, 112.3772 +8489, 68.12769, 115.3454 +8490, 66.9149, 122.5675 +8491, 69.55254, 107.2211 +8492, 67.09352, 114.081 +8493, 71.3619, 124.5166 +8494, 71.16679, 137.383 +8495, 69.36125, 133.1983 +8496, 65.62974, 116.7798 +8497, 67.50367, 153.339 +8498, 71.06365, 136.3467 +8499, 66.49246, 117.7597 +8500, 69.98023, 135.4338 +8501, 66.36915, 120.7832 +8502, 65.72799, 129.9118 +8503, 67.22453, 138.4072 +8504, 69.6795, 128.9191 +8505, 66.91326, 111.703 +8506, 68.26178, 128.2739 +8507, 64.98478, 119.1325 +8508, 68.0698, 104.76 +8509, 68.61422, 136.6399 +8510, 66.30294, 132.3913 +8511, 68.38352, 142.0639 +8512, 65.93684, 130.2864 +8513, 69.26443, 144.1251 +8514, 69.85744, 132.3308 +8515, 67.08825, 127.413 +8516, 63.19953, 106.8324 +8517, 72.94152, 125.7713 +8518, 70.37958, 151.8206 +8519, 66.63283, 118.6562 +8520, 72.50855, 141.1954 +8521, 71.36999, 125.1979 +8522, 68.75583, 138.7086 +8523, 69.62903, 120.2989 +8524, 68.16407, 117.9536 +8525, 66.83708, 122.0631 +8526, 70.18194, 156.4056 +8527, 67.86367, 114.9246 +8528, 71.10272, 130.4239 +8529, 73.58262, 141.6525 +8530, 68.32952, 134.7504 +8531, 66.44661, 121.6314 +8532, 67.18734, 118.6352 +8533, 67.49287, 122.4953 +8534, 66.38595, 119.4673 +8535, 67.25681, 121.2471 +8536, 69.31111, 136.4983 +8537, 68.14806, 117.3852 +8538, 68.12645, 115.4428 +8539, 66.38526, 135.9818 +8540, 67.65899, 127.3092 +8541, 69.58252, 114.6022 +8542, 67.4652, 125.8834 +8543, 66.54185, 121.2715 +8544, 67.20255, 143.0669 +8545, 67.9341, 106.4818 +8546, 64.97055, 113.4885 +8547, 69.56655, 133.0219 +8548, 70.30948, 141.6156 +8549, 69.61829, 138.6939 +8550, 65.59094, 104.0323 +8551, 67.8259, 119.8473 +8552, 68.03804, 119.9125 +8553, 68.19362, 125.7243 +8554, 68.25109, 115.4595 +8555, 68.43965, 121.7398 +8556, 66.34605, 150.4439 +8557, 68.58532, 138.1689 +8558, 68.55442, 141.2293 +8559, 71.03808, 129.7799 +8560, 64.47771, 122.9159 +8561, 64.58247, 122.8109 +8562, 70.13052, 117.7137 +8563, 64.90601, 125.232 +8564, 68.99646, 124.495 +8565, 67.61832, 115.7638 +8566, 69.63195, 140.8429 +8567, 66.05471, 111.8194 +8568, 71.32499, 127.1661 +8569, 67.85806, 138.4063 +8570, 69.45941, 135.9299 +8571, 66.64834, 127.7205 +8572, 64.97782, 110.4212 +8573, 67.87711, 122.438 +8574, 72.31294, 136.5598 +8575, 67.14057, 134.0436 +8576, 64.43728, 114.5911 +8577, 66.67002, 117.9921 +8578, 68.59476, 128.0073 +8579, 71.47766, 129.924 +8580, 68.63009, 125.5075 +8581, 67.6305, 120.5523 +8582, 70.06317, 126.4208 +8583, 67.44197, 123.631 +8584, 68.03318, 115.4171 +8585, 67.4692, 129.6403 +8586, 68.92912, 110.1478 +8587, 67.31979, 115.8672 +8588, 68.047, 133.8044 +8589, 67.90838, 136.5008 +8590, 69.6925, 124.0748 +8591, 68.62706, 130.6542 +8592, 68.84882, 148.3087 +8593, 66.59651, 123.5118 +8594, 68.15322, 133.3485 +8595, 68.66291, 110.1892 +8596, 69.21557, 124.0764 +8597, 67.36, 129.7241 +8598, 68.07738, 104.7027 +8599, 66.52751, 134.1397 +8600, 70.42237, 136.6591 +8601, 67.07823, 132.8673 +8602, 66.43387, 126.4911 +8603, 67.98753, 114.7128 +8604, 71.27188, 158.4771 +8605, 68.04701, 123.3098 +8606, 72.61099, 142.6713 +8607, 64.68513, 115.842 +8608, 68.43352, 97.83008 +8609, 67.27211, 125.707 +8610, 68.75891, 138.2249 +8611, 68.49528, 116.3683 +8612, 69.2542, 151.8387 +8613, 68.77305, 127.9952 +8614, 65.17589, 111.4943 +8615, 68.21604, 119.0602 +8616, 67.30043, 120.3285 +8617, 67.86067, 115.128 +8618, 66.00059, 120.3097 +8619, 66.6625, 120.4223 +8620, 67.60112, 129.1886 +8621, 69.01782, 125.8767 +8622, 65.7622, 111.3564 +8623, 66.63706, 127.3243 +8624, 68.11546, 130.3186 +8625, 66.70442, 127.4867 +8626, 70.22831, 144.6741 +8627, 66.28448, 126.7203 +8628, 71.60477, 141.1438 +8629, 68.82431, 135.5828 +8630, 69.98686, 138.3058 +8631, 68.30179, 129.9339 +8632, 66.6512, 119.0595 +8633, 63.50812, 129.557 +8634, 69.5967, 136.7802 +8635, 64.89411, 124.4031 +8636, 67.67866, 129.976 +8637, 66.70638, 116.4489 +8638, 67.10993, 102.8583 +8639, 69.90802, 140.878 +8640, 67.71135, 122.7092 +8641, 67.5598, 119.3298 +8642, 64.20492, 103.6839 +8643, 71.00101, 135.5008 +8644, 68.81199, 109.4734 +8645, 67.94764, 108.1062 +8646, 68.21642, 131.4376 +8647, 66.17682, 125.3836 +8648, 68.69922, 144.3117 +8649, 68.70501, 109.3633 +8650, 69.61334, 125.4205 +8651, 69.75186, 122.5754 +8652, 71.46053, 148.6212 +8653, 69.36257, 111.1764 +8654, 67.40368, 109.3832 +8655, 69.81058, 119.4349 +8656, 70.47149, 140.3522 +8657, 66.7402, 143.1496 +8658, 63.91222, 105.8021 +8659, 67.8694, 136.8885 +8660, 66.84936, 116.9535 +8661, 66.07377, 115.9419 +8662, 68.48646, 133.3074 +8663, 71.77202, 141.7503 +8664, 67.55856, 137.7559 +8665, 66.28302, 134.3729 +8666, 68.43875, 119.3438 +8667, 67.07508, 115.6909 +8668, 70.60636, 122.1442 +8669, 68.8942, 135.3984 +8670, 69.88244, 134.3577 +8671, 68.93627, 138.0941 +8672, 65.14713, 117.9849 +8673, 68.68398, 136.8724 +8674, 67.56665, 117.9312 +8675, 68.73881, 145.8697 +8676, 68.96333, 119.0578 +8677, 68.5465, 121.7189 +8678, 67.85396, 121.6697 +8679, 64.96046, 127.6795 +8680, 68.58674, 129.2295 +8681, 67.92544, 110.8076 +8682, 69.3629, 118.6172 +8683, 70.90905, 146.5188 +8684, 69.28772, 132.6966 +8685, 69.06553, 119.9738 +8686, 66.60716, 109.856 +8687, 69.19515, 118.2264 +8688, 69.42865, 128.6528 +8689, 70.09399, 127.3597 +8690, 64.50077, 103.3027 +8691, 65.72099, 115.9257 +8692, 66.05702, 112.889 +8693, 62.40403, 118.5959 +8694, 72.90965, 148.6113 +8695, 66.22193, 131.9039 +8696, 65.97161, 129.6126 +8697, 67.82515, 122.1707 +8698, 71.16689, 152.1123 +8699, 65.46284, 101.8952 +8700, 68.92267, 144.0831 +8701, 68.57821, 137.295 +8702, 68.53972, 141.0431 +8703, 66.17685, 131.7326 +8704, 70.90225, 143.3108 +8705, 69.42553, 114.8461 +8706, 67.5235, 107.4208 +8707, 67.09865, 110.2544 +8708, 66.84169, 121.8217 +8709, 67.80772, 126.529 +8710, 67.14173, 121.3218 +8711, 70.57017, 137.4274 +8712, 65.05533, 125.8786 +8713, 70.03645, 139.6533 +8714, 66.21546, 118.4718 +8715, 63.142, 127.3112 +8716, 64.01004, 105.3351 +8717, 69.0029, 124.9629 +8718, 65.635, 105.3681 +8719, 68.59588, 121.1566 +8720, 68.8021, 142.3453 +8721, 69.03779, 122.1038 +8722, 67.04484, 116.5428 +8723, 66.03639, 117.0908 +8724, 69.62664, 127.3049 +8725, 67.3924, 113.4762 +8726, 71.00376, 134.5287 +8727, 67.93633, 114.9908 +8728, 68.63648, 129.2673 +8729, 68.62805, 126.3473 +8730, 67.83335, 142.6824 +8731, 67.39028, 122.0253 +8732, 68.46455, 114.5964 +8733, 70.16762, 123.31 +8734, 68.79997, 144.323 +8735, 68.04005, 117.5716 +8736, 68.0575, 144.1516 +8737, 69.66688, 128.3014 +8738, 67.88892, 138.9831 +8739, 69.43039, 128.4548 +8740, 68.70589, 151.2938 +8741, 66.73086, 116.8306 +8742, 69.36545, 128.6177 +8743, 68.02714, 145.0769 +8744, 65.88695, 111.8354 +8745, 68.57752, 146.3214 +8746, 67.04267, 116.0189 +8747, 69.64171, 135.2526 +8748, 69.28691, 124.1958 +8749, 68.2993, 122.8095 +8750, 66.59117, 112.9433 +8751, 66.00152, 119.4182 +8752, 69.62369, 135.4419 +8753, 70.40944, 160.9728 +8754, 68.23792, 132.3743 +8755, 71.33673, 144.0178 +8756, 68.26044, 128.1884 +8757, 65.19386, 118.5785 +8758, 64.97013, 128.0257 +8759, 65.48129, 117.1136 +8760, 70.81532, 136.8483 +8761, 69.65288, 132.9662 +8762, 70.7431, 124.3004 +8763, 66.577, 132.3608 +8764, 68.31897, 108.4509 +8765, 69.58153, 136.53 +8766, 70.24671, 121.6743 +8767, 69.53121, 126.6608 +8768, 71.23578, 121.6717 +8769, 66.48996, 115.6813 +8770, 67.1513, 130.6168 +8771, 69.49518, 131.1111 +8772, 65.40644, 123.0377 +8773, 68.65428, 134.1447 +8774, 65.08665, 120.4446 +8775, 70.78233, 122.2947 +8776, 62.42388, 113.2646 +8777, 66.71211, 116.8734 +8778, 69.29174, 117.5564 +8779, 63.91813, 114.1919 +8780, 65.76518, 117.0031 +8781, 70.68956, 135.662 +8782, 69.1483, 139.0431 +8783, 71.15854, 131.258 +8784, 66.39543, 116.2256 +8785, 69.95913, 132.8145 +8786, 68.85974, 134.8338 +8787, 70.30886, 134.2011 +8788, 66.47109, 113.7779 +8789, 67.99054, 138.8971 +8790, 67.72173, 136.0789 +8791, 67.42949, 135.9047 +8792, 65.98761, 110.2969 +8793, 68.0763, 117.3088 +8794, 67.58576, 113.3246 +8795, 67.71976, 97.61996 +8796, 65.7482, 99.90975 +8797, 69.3897, 133.682 +8798, 66.36935, 129.6092 +8799, 69.79204, 140.811 +8800, 67.75389, 126.4157 +8801, 70.21143, 131.9105 +8802, 68.67792, 122.0728 +8803, 71.14142, 130.5105 +8804, 66.40101, 130.5867 +8805, 67.0502, 143.097 +8806, 66.77997, 117.1269 +8807, 64.5675, 100.9 +8808, 66.79296, 116.9012 +8809, 69.70535, 119.1882 +8810, 67.51715, 133.8952 +8811, 66.77383, 112.0133 +8812, 69.09905, 132.1341 +8813, 67.74778, 117.103 +8814, 67.68924, 111.3426 +8815, 65.58171, 115.5257 +8816, 69.80522, 139.7323 +8817, 67.47119, 141.2489 +8818, 65.65515, 131.7992 +8819, 67.37904, 112.7464 +8820, 69.71522, 125.2627 +8821, 68.11911, 114.1017 +8822, 68.59547, 117.342 +8823, 66.91329, 119.7384 +8824, 72.74978, 139.9267 +8825, 67.06735, 124.2893 +8826, 71.35418, 132.9339 +8827, 67.5378, 129.0482 +8828, 68.37558, 125.9097 +8829, 74.2727, 144.66 +8830, 68.70571, 132.7107 +8831, 67.62161, 132.7596 +8832, 68.57034, 125.0608 +8833, 67.58944, 131.7524 +8834, 64.2441, 112.828 +8835, 72.21166, 122.8259 +8836, 68.45109, 112.7446 +8837, 65.7402, 117.7157 +8838, 67.53807, 118.2423 +8839, 69.22881, 125.0318 +8840, 69.15576, 131.5739 +8841, 67.69635, 125.4574 +8842, 68.38781, 120.6513 +8843, 71.73727, 140.9432 +8844, 66.9098, 127.8661 +8845, 70.38323, 152.929 +8846, 69.616, 135.0082 +8847, 65.52145, 113.0211 +8848, 69.55694, 136.8874 +8849, 65.82438, 121.7984 +8850, 69.7416, 135.4599 +8851, 67.47711, 115.5446 +8852, 68.09913, 124.585 +8853, 68.20718, 122.9659 +8854, 68.15528, 129.7591 +8855, 67.63533, 121.6332 +8856, 70.15607, 144.7042 +8857, 64.91503, 114.1893 +8858, 69.0054, 119.5523 +8859, 68.26633, 126.4766 +8860, 68.81612, 140.2813 +8861, 67.72767, 134.104 +8862, 66.56438, 132.7397 +8863, 68.46206, 133.381 +8864, 69.6475, 146.482 +8865, 62.35553, 102.9535 +8866, 67.59977, 125.9471 +8867, 67.51383, 129.5542 +8868, 66.45122, 108.2905 +8869, 70.00417, 140.7597 +8870, 65.68838, 119.2997 +8871, 67.84561, 142.0715 +8872, 70.29979, 138.4229 +8873, 67.12263, 136.7691 +8874, 70.32632, 127.1832 +8875, 67.38624, 143.2195 +8876, 67.12831, 130.1144 +8877, 69.37649, 135.3031 +8878, 68.40369, 144.1206 +8879, 65.88697, 128.0762 +8880, 66.24954, 102.3152 +8881, 66.20872, 121.6419 +8882, 65.47065, 120.9183 +8883, 70.80619, 130.7321 +8884, 69.68347, 120.7878 +8885, 68.57948, 111.95 +8886, 66.70391, 125.3796 +8887, 66.30788, 114.9262 +8888, 69.067, 129.1566 +8889, 65.69589, 125.6365 +8890, 67.3335, 128.6592 +8891, 67.26527, 115.5412 +8892, 65.87646, 136.2664 +8893, 68.78703, 133.1355 +8894, 68.46685, 133.7184 +8895, 68.17238, 123.3582 +8896, 68.00351, 129.994 +8897, 66.43891, 119.1959 +8898, 63.11944, 114.2425 +8899, 66.48446, 134.239 +8900, 66.55759, 108.1273 +8901, 68.58831, 141.7279 +8902, 65.54854, 128.616 +8903, 71.75568, 121.5435 +8904, 70.01805, 131.2352 +8905, 69.30459, 129.3077 +8906, 64.5266, 109.4324 +8907, 67.82493, 110.6918 +8908, 69.30746, 129.188 +8909, 67.17495, 123.1006 +8910, 67.19047, 111.219 +8911, 65.90544, 115.406 +8912, 67.25979, 131.1541 +8913, 66.3908, 118.4527 +8914, 67.37297, 113.7344 +8915, 70.31688, 134.466 +8916, 66.97896, 103.6181 +8917, 71.16515, 136.0685 +8918, 66.52982, 123.7617 +8919, 70.51065, 135.3067 +8920, 66.86786, 123.6055 +8921, 66.87611, 93.44279 +8922, 69.98701, 124.1901 +8923, 66.47468, 119.4661 +8924, 68.24878, 143.1334 +8925, 64.20728, 115.7541 +8926, 66.79236, 122.1444 +8927, 67.78383, 115.3515 +8928, 67.66018, 131.4295 +8929, 67.83249, 114.4112 +8930, 68.97089, 128.8479 +8931, 68.67746, 130.8949 +8932, 65.63126, 139.7057 +8933, 69.17205, 132.7823 +8934, 66.06605, 118.503 +8935, 67.93043, 132.0073 +8936, 68.33555, 137.7148 +8937, 69.22538, 145.6323 +8938, 69.05205, 140.8625 +8939, 71.78468, 148.0053 +8940, 68.63056, 140.2105 +8941, 67.25523, 112.3407 +8942, 70.44291, 124 +8943, 69.02526, 107.2311 +8944, 68.81653, 108.159 +8945, 69.4793, 123.016 +8946, 65.28886, 114.7259 +8947, 70.23626, 141.6617 +8948, 68.90008, 143.8243 +8949, 65.76153, 132.5244 +8950, 64.57852, 104.3304 +8951, 67.14474, 123.891 +8952, 65.21882, 105.491 +8953, 67.25521, 126.629 +8954, 67.25235, 137.5721 +8955, 65.77614, 132.6912 +8956, 62.6827, 96.03438 +8957, 70.0801, 137.082 +8958, 69.05895, 144.3368 +8959, 69.86644, 122.0803 +8960, 67.76916, 131.7569 +8961, 68.01168, 125.3418 +8962, 66.68649, 137.3589 +8963, 65.92248, 118.8738 +8964, 65.33207, 108.8749 +8965, 67.42605, 121.8715 +8966, 69.36554, 128.6365 +8967, 67.40751, 138.2898 +8968, 66.57351, 140.3651 +8969, 67.17337, 121.0826 +8970, 68.99306, 154.9503 +8971, 64.54104, 122.436 +8972, 67.54151, 117.6445 +8973, 68.58505, 127.7326 +8974, 71.98814, 137.2838 +8975, 67.65459, 154.9403 +8976, 67.6661, 130.5926 +8977, 66.14316, 134.4043 +8978, 66.40155, 140.8314 +8979, 67.07434, 137.5925 +8980, 68.20422, 135.581 +8981, 70.48362, 139.2976 +8982, 68.67658, 134.969 +8983, 67.74427, 124.1332 +8984, 69.67541, 132.6086 +8985, 68.39295, 142.5965 +8986, 63.70222, 109.7699 +8987, 66.64859, 108.9945 +8988, 67.90407, 124.9492 +8989, 66.5197, 111.722 +8990, 66.54521, 133.7914 +8991, 71.96799, 144.5037 +8992, 67.20094, 147.7364 +8993, 68.71458, 118.739 +8994, 63.79579, 113.0481 +8995, 66.9737, 122.7246 +8996, 69.76872, 127.523 +8997, 67.94033, 126.2715 +8998, 69.44812, 126.0498 +8999, 68.05029, 120.1885 +9000, 68.01797, 133.8531 +9001, 64.38451, 120.9878 +9002, 65.25758, 104.4308 +9003, 70.47138, 138.5686 +9004, 68.16951, 136.5314 +9005, 65.04024, 117.8342 +9006, 66.39263, 137.6273 +9007, 67.60452, 139.128 +9008, 67.84567, 128.5574 +9009, 68.50322, 129.6116 +9010, 69.52893, 132.6006 +9011, 68.12778, 112.1998 +9012, 67.38512, 128.4802 +9013, 65.6983, 108.4186 +9014, 68.53813, 124.2629 +9015, 67.344, 115.9541 +9016, 70.01961, 138.2804 +9017, 67.40743, 130.7949 +9018, 70.17944, 141.0758 +9019, 66.51343, 128.4216 +9020, 67.26656, 125.9014 +9021, 66.31374, 111.5275 +9022, 68.44896, 123.68 +9023, 69.27778, 129.0046 +9024, 64.42384, 129.7849 +9025, 66.70168, 130.5984 +9026, 69.24707, 115.7079 +9027, 66.28284, 114.6304 +9028, 69.63326, 124.6271 +9029, 71.70174, 132.1551 +9030, 66.93376, 131.3089 +9031, 67.21461, 138.1399 +9032, 67.3223, 118.8846 +9033, 68.78724, 120.7674 +9034, 70.04804, 142.6447 +9035, 67.87706, 143.2935 +9036, 67.02932, 125.1984 +9037, 69.64922, 154.6918 +9038, 71.22213, 122.1485 +9039, 69.66832, 127.8876 +9040, 67.96253, 127.4414 +9041, 67.00064, 113.6904 +9042, 70.48193, 129.2246 +9043, 68.55545, 125.4016 +9044, 68.7117, 149.996 +9045, 67.31232, 129.0666 +9046, 70.2357, 130.3049 +9047, 69.62229, 134.6101 +9048, 66.48154, 137.9908 +9049, 67.07917, 133.1644 +9050, 69.67002, 140.8713 +9051, 69.14091, 141.8583 +9052, 67.16885, 121.6772 +9053, 68.66029, 123.5929 +9054, 70.01551, 129.615 +9055, 65.91776, 121.563 +9056, 68.37937, 131.1613 +9057, 72.03353, 116.3468 +9058, 67.4263, 143.0452 +9059, 66.83514, 104.2224 +9060, 70.8882, 133.5063 +9061, 71.09886, 134.4454 +9062, 68.28929, 130.8796 +9063, 67.42232, 124.5761 +9064, 68.77046, 110.9432 +9065, 66.44097, 107.1578 +9066, 66.90499, 120.1547 +9067, 67.74564, 134.8147 +9068, 69.8243, 128.6697 +9069, 68.53948, 137.0614 +9070, 67.01536, 123.0206 +9071, 68.72506, 124.6451 +9072, 68.35119, 133.4171 +9073, 67.19257, 129.0612 +9074, 69.5455, 133.8347 +9075, 68.59743, 132.2555 +9076, 67.24215, 119.4882 +9077, 66.65525, 129.5077 +9078, 64.90589, 136.4502 +9079, 69.23991, 127.3088 +9080, 68.56348, 111.6024 +9081, 66.34211, 114.1735 +9082, 70.38965, 111.2858 +9083, 69.41526, 138.7516 +9084, 69.27737, 111.6005 +9085, 68.38301, 134.017 +9086, 67.157, 124.2264 +9087, 68.20503, 113.3739 +9088, 68.72586, 131.5592 +9089, 66.96037, 125.1157 +9090, 66.66717, 124.2017 +9091, 70.07603, 139.5844 +9092, 70.51629, 136.3324 +9093, 71.54106, 126.4717 +9094, 67.50481, 141.2498 +9095, 69.15991, 113.6123 +9096, 67.90658, 132.8133 +9097, 68.82477, 120.2753 +9098, 69.78004, 123.8703 +9099, 68.44619, 138.1636 +9100, 69.39772, 118.0079 +9101, 67.30346, 141.5997 +9102, 65.66713, 128.864 +9103, 67.33725, 124.8425 +9104, 67.00093, 128.6654 +9105, 65.45347, 108.3017 +9106, 66.65036, 116.8012 +9107, 66.62187, 120.3299 +9108, 71.06319, 131.0404 +9109, 66.53966, 119.8203 +9110, 66.05713, 113.8325 +9111, 64.81538, 123.0207 +9112, 67.82121, 124.0312 +9113, 69.91442, 131.4753 +9114, 67.20148, 119.7628 +9115, 69.57829, 133.2355 +9116, 69.56702, 143.8267 +9117, 67.25014, 127.6431 +9118, 66.31447, 106.2018 +9119, 69.82058, 110.6276 +9120, 64.68698, 117.9638 +9121, 68.52069, 142.1197 +9122, 68.05361, 137.0546 +9123, 63.88492, 122.967 +9124, 65.87122, 135.4564 +9125, 67.28386, 141.0113 +9126, 68.7451, 145.1448 +9127, 71.78732, 127.6009 +9128, 71.89347, 142.8591 +9129, 71.21521, 140.5748 +9130, 68.63924, 121.7655 +9131, 67.20198, 127.4781 +9132, 68.42171, 116.4237 +9133, 66.21571, 132.8434 +9134, 65.69602, 114.2603 +9135, 64.39471, 108.8848 +9136, 68.13221, 126.5235 +9137, 69.95789, 157.8629 +9138, 66.17437, 124.0197 +9139, 67.3027, 108.836 +9140, 67.12352, 139.5505 +9141, 66.13041, 114.8118 +9142, 66.76283, 132.985 +9143, 69.81734, 140.8902 +9144, 67.50491, 126.0354 +9145, 67.77868, 132.7541 +9146, 67.09294, 134.424 +9147, 69.02064, 139.6542 +9148, 68.37429, 127.5258 +9149, 64.61585, 131.0972 +9150, 65.50846, 146.5505 +9151, 68.56092, 114.3385 +9152, 69.29465, 137.8696 +9153, 67.29291, 135.6857 +9154, 67.10227, 117.0417 +9155, 66.23273, 128.5774 +9156, 68.91376, 140.9367 +9157, 66.75178, 132.2723 +9158, 67.13916, 111.5926 +9159, 66.25471, 126.3462 +9160, 69.74556, 153.9188 +9161, 66.34128, 128.7754 +9162, 69.83341, 108.9893 +9163, 69.86248, 137.0186 +9164, 70.28256, 118.5086 +9165, 67.07699, 130.1395 +9166, 68.18059, 123.6302 +9167, 67.59916, 128.1213 +9168, 68.02776, 140.8584 +9169, 68.42296, 121.4696 +9170, 66.75944, 112.3085 +9171, 68.53352, 124.2808 +9172, 65.2651, 110.8564 +9173, 66.58553, 122.2553 +9174, 69.2084, 130.033 +9175, 66.78219, 103.0118 +9176, 69.73097, 129.0492 +9177, 69.25719, 123.1632 +9178, 68.57908, 114.3083 +9179, 68.38491, 130.869 +9180, 67.35514, 119.3197 +9181, 70.08283, 124.9148 +9182, 69.17193, 140.6591 +9183, 70.74539, 125.966 +9184, 65.88537, 138.3547 +9185, 66.18373, 113.7313 +9186, 64.9891, 120.7808 +9187, 70.07851, 129.7672 +9188, 67.47051, 123.0945 +9189, 71.44337, 130.4157 +9190, 69.28932, 137.6776 +9191, 68.75846, 127.091 +9192, 67.99864, 135.3502 +9193, 66.76007, 111.1036 +9194, 71.10275, 126.991 +9195, 68.84929, 133.7133 +9196, 66.71258, 125.7664 +9197, 69.69606, 131.6194 +9198, 68.21523, 137.7177 +9199, 69.19788, 125.6089 +9200, 65.99751, 120.2086 +9201, 67.06344, 119.1764 +9202, 70.38879, 148.7394 +9203, 66.85526, 130.9888 +9204, 65.49447, 116.2783 +9205, 66.4933, 131.4317 +9206, 69.64591, 135.8083 +9207, 66.6031, 120.0463 +9208, 65.5028, 110.0927 +9209, 70.68042, 145.9 +9210, 68.35984, 115.3059 +9211, 69.67952, 138.7123 +9212, 67.28637, 138.2075 +9213, 64.24975, 131.6321 +9214, 69.59961, 152.9562 +9215, 67.2586, 136.0419 +9216, 65.07024, 110.1766 +9217, 69.32643, 131.1248 +9218, 65.74804, 114.0431 +9219, 67.8373, 124.0473 +9220, 67.68655, 124.5785 +9221, 69.93319, 129.2833 +9222, 66.7117, 111.267 +9223, 71.46877, 126.8355 +9224, 69.23864, 119.7615 +9225, 66.93836, 119.0544 +9226, 73.75335, 153.1022 +9227, 68.52941, 129.8379 +9228, 65.84612, 127.4989 +9229, 69.14293, 130.5126 +9230, 68.50756, 128.4389 +9231, 68.80941, 150.2088 +9232, 68.28658, 116.4148 +9233, 66.0851, 122.6038 +9234, 66.76815, 124.7948 +9235, 68.41582, 127.8615 +9236, 67.86012, 138.798 +9237, 66.49326, 128.5167 +9238, 70.05556, 145.7431 +9239, 71.51172, 128.1476 +9240, 69.63168, 160.4111 +9241, 67.31178, 106.3544 +9242, 65.9605, 126.6596 +9243, 68.69762, 139.7047 +9244, 70.5427, 147.6912 +9245, 65.2308, 116.3007 +9246, 65.7164, 94.98665 +9247, 66.6851, 123.8638 +9248, 68.30596, 108.0676 +9249, 70.06674, 130.9781 +9250, 67.06764, 131.5991 +9251, 68.67723, 126.1419 +9252, 66.56482, 118.4916 +9253, 67.928, 139.2513 +9254, 67.81441, 123.6647 +9255, 68.05175, 133.8927 +9256, 65.16729, 121.1432 +9257, 68.4387, 128.4782 +9258, 69.90595, 133.594 +9259, 67.5131, 131.9657 +9260, 70.55747, 143.9102 +9261, 67.50352, 125.0155 +9262, 70.8343, 144.4515 +9263, 67.17439, 129.7009 +9264, 68.23162, 132.8397 +9265, 68.84891, 141.2839 +9266, 66.06507, 118.4233 +9267, 67.96066, 124.5333 +9268, 64.42169, 119.2322 +9269, 68.9783, 145.197 +9270, 68.86452, 133.6579 +9271, 67.51935, 123.6148 +9272, 70.8742, 127.9931 +9273, 65.63908, 125.7235 +9274, 72.06149, 147.5819 +9275, 70.74003, 147.7738 +9276, 69.53497, 141.9338 +9277, 66.04415, 121.9856 +9278, 67.75988, 140.1278 +9279, 67.28678, 131.5009 +9280, 66.58203, 122.171 +9281, 67.00829, 127.8757 +9282, 67.14315, 114.6482 +9283, 69.52981, 128.8579 +9284, 69.01236, 146.6218 +9285, 67.53657, 100.154 +9286, 68.06545, 141.5315 +9287, 69.27853, 143.8148 +9288, 68.96647, 136.0886 +9289, 68.75452, 129.4726 +9290, 67.32854, 107.9528 +9291, 69.0599, 131.2881 +9292, 69.76801, 132.0979 +9293, 72.03679, 138.0884 +9294, 64.54425, 115.9595 +9295, 63.63284, 107.2702 +9296, 70.94818, 149.7548 +9297, 62.91288, 109.2128 +9298, 69.4062, 124.5456 +9299, 65.4398, 136.8947 +9300, 67.05728, 122.9843 +9301, 66.18541, 121.9805 +9302, 66.90237, 139.8915 +9303, 66.41367, 109.0311 +9304, 67.67042, 123.1408 +9305, 67.70967, 131.7281 +9306, 66.69404, 126.8929 +9307, 69.5217, 126.8198 +9308, 68.20773, 119.5053 +9309, 67.99821, 127.458 +9310, 68.00746, 119.2101 +9311, 68.09824, 143.5727 +9312, 68.93312, 143.0937 +9313, 69.78307, 139.0177 +9314, 65.81071, 114.1338 +9315, 69.96713, 125.4353 +9316, 67.5085, 127.8424 +9317, 69.09305, 140.226 +9318, 72.36277, 135.6763 +9319, 67.6456, 123.0015 +9320, 69.46842, 119.0737 +9321, 66.77116, 129.5425 +9322, 70.23323, 135.7363 +9323, 69.55395, 139.2316 +9324, 69.35355, 128.9771 +9325, 67.2451, 130.0655 +9326, 64.77727, 143.251 +9327, 66.30059, 112.3781 +9328, 66.75624, 125.1407 +9329, 65.73325, 134.9375 +9330, 68.08852, 111.6419 +9331, 71.55699, 141.6861 +9332, 67.38427, 122.8404 +9333, 64.15481, 101.7546 +9334, 68.50089, 121.5853 +9335, 69.27158, 135.7448 +9336, 68.52587, 131.2739 +9337, 66.81053, 127.0045 +9338, 70.0217, 132.9266 +9339, 70.44212, 135.0743 +9340, 70.35346, 118.347 +9341, 65.94226, 136.2054 +9342, 67.49783, 121.6583 +9343, 68.00099, 127.1241 +9344, 65.48962, 99.76843 +9345, 66.86327, 124.5651 +9346, 69.4656, 131.2397 +9347, 67.40982, 113.6502 +9348, 65.75113, 117.6909 +9349, 69.07002, 130.5795 +9350, 69.3032, 128.7739 +9351, 67.27013, 136.5165 +9352, 68.29642, 132.8802 +9353, 65.5358, 108.0334 +9354, 67.22288, 138.325 +9355, 69.02293, 143.8474 +9356, 66.69251, 130.6489 +9357, 66.50669, 131.5283 +9358, 67.98874, 146.0239 +9359, 66.65476, 125.3253 +9360, 69.12208, 129.0318 +9361, 71.02363, 144.1068 +9362, 66.46702, 119.3847 +9363, 69.03081, 134.2694 +9364, 65.9942, 128.0366 +9365, 66.54171, 133.9323 +9366, 65.91998, 135.6308 +9367, 70.59103, 134.1319 +9368, 65.78822, 134.2213 +9369, 69.91804, 119.5102 +9370, 64.2992, 126.3063 +9371, 66.42226, 113.4779 +9372, 68.74988, 136.8669 +9373, 67.99798, 118.1315 +9374, 64.60634, 122.632 +9375, 67.88746, 119.0272 +9376, 66.81948, 125.9408 +9377, 69.06944, 159.9584 +9378, 65.65385, 129.1825 +9379, 66.2017, 114.629 +9380, 68.94276, 135.2118 +9381, 68.3649, 119.517 +9382, 67.18992, 127.9725 +9383, 66.68348, 119.6796 +9384, 67.43443, 120.3906 +9385, 67.21497, 119.7199 +9386, 68.45993, 121.1754 +9387, 63.64325, 117.4774 +9388, 67.53521, 146.869 +9389, 69.70037, 128.112 +9390, 68.29865, 122.6236 +9391, 67.97567, 130.0032 +9392, 69.57423, 130.6273 +9393, 66.70797, 142.0475 +9394, 67.9214, 110.3853 +9395, 67.40188, 124.1551 +9396, 69.39159, 121.5433 +9397, 68.59889, 127.6063 +9398, 68.3755, 126.0555 +9399, 68.28427, 127.0948 +9400, 68.50766, 152.6424 +9401, 65.09736, 111.7652 +9402, 65.83359, 119.9561 +9403, 69.25932, 134.0319 +9404, 68.73092, 132.3239 +9405, 66.77164, 120.5926 +9406, 66.38506, 142.6708 +9407, 67.46704, 132.4481 +9408, 68.17097, 123.7398 +9409, 65.70973, 125.7159 +9410, 67.07386, 121.8819 +9411, 71.9948, 147.5977 +9412, 63.22211, 107.5164 +9413, 69.03411, 118.9953 +9414, 68.64248, 120.9374 +9415, 65.9252, 118.0381 +9416, 72.10915, 143.0039 +9417, 66.35575, 107.5936 +9418, 68.96323, 128.6853 +9419, 65.42432, 116.2966 +9420, 65.22177, 112.5281 +9421, 72.70766, 151.2249 +9422, 67.3917, 106.0426 +9423, 66.68077, 127.0893 +9424, 68.72378, 129.9631 +9425, 63.70105, 109.8656 +9426, 73.02554, 153.6723 +9427, 68.16631, 126.7726 +9428, 64.82933, 95.71141 +9429, 65.8334, 119.1656 +9430, 67.8251, 129.8443 +9431, 69.45504, 143.627 +9432, 63.03704, 117.6276 +9433, 67.58447, 125.4967 +9434, 66.92223, 122.307 +9435, 69.33008, 135.0667 +9436, 71.71882, 146.1847 +9437, 68.66466, 137.1764 +9438, 70.46171, 120.4257 +9439, 64.20227, 124.2804 +9440, 68.54482, 122.1992 +9441, 65.42611, 118.5156 +9442, 69.20541, 135.4161 +9443, 63.51326, 105.9244 +9444, 67.2175, 111.7119 +9445, 69.69215, 143.5628 +9446, 68.78018, 132.1932 +9447, 69.40612, 120.9522 +9448, 67.40414, 121.3496 +9449, 67.40661, 109.3581 +9450, 66.49497, 124.8437 +9451, 67.2151, 120.043 +9452, 69.36059, 124.4044 +9453, 69.68186, 147.5598 +9454, 67.6277, 160.2278 +9455, 67.89343, 154.2345 +9456, 70.64483, 129.7265 +9457, 70.8271, 131.8696 +9458, 66.95277, 150.2868 +9459, 66.46976, 123.0618 +9460, 66.54555, 124.8628 +9461, 68.16788, 146.6505 +9462, 66.2086, 115.1943 +9463, 68.33636, 135.8657 +9464, 64.5222, 96.68665 +9465, 65.57641, 117.1727 +9466, 69.2064, 124.3249 +9467, 69.07345, 156.9797 +9468, 68.94109, 130.1473 +9469, 68.07446, 143.6574 +9470, 72.00843, 133.2257 +9471, 67.20444, 139.7736 +9472, 68.43894, 124.1119 +9473, 68.23881, 111.9836 +9474, 70.52936, 122.4652 +9475, 67.32161, 124.3376 +9476, 69.95585, 147.535 +9477, 67.88682, 135.3697 +9478, 68.15578, 106.8394 +9479, 70.56446, 124.0626 +9480, 68.13215, 104.8113 +9481, 70.25892, 129.4346 +9482, 71.06535, 140.4796 +9483, 66.36966, 116.5041 +9484, 67.17026, 135.8317 +9485, 68.87325, 146.9941 +9486, 70.81794, 131.5906 +9487, 66.72765, 121.3333 +9488, 67.48404, 137.405 +9489, 66.53552, 138.7161 +9490, 68.04662, 127.0141 +9491, 67.85401, 129.9666 +9492, 68.00799, 119.6399 +9493, 74.05895, 133.8172 +9494, 68.49073, 130.7902 +9495, 64.60903, 96.02104 +9496, 67.56038, 127.1691 +9497, 68.62368, 123.8232 +9498, 67.25436, 142.156 +9499, 68.17591, 127.1837 +9500, 67.57397, 132.4176 +9501, 66.05092, 103.9482 +9502, 69.27344, 127.5728 +9503, 69.90864, 121.1529 +9504, 69.28147, 140.9313 +9505, 68.75275, 132.5807 +9506, 67.33384, 115.6858 +9507, 65.05656, 111.7393 +9508, 65.67598, 111.3916 +9509, 66.47819, 101.3276 +9510, 70.52868, 134.6246 +9511, 67.33753, 109.9394 +9512, 69.87287, 126.1665 +9513, 68.73321, 125.7578 +9514, 69.1104, 140.1776 +9515, 69.1176, 120.5052 +9516, 66.72791, 116.0508 +9517, 70.37952, 130.6461 +9518, 64.75996, 110.5434 +9519, 67.50912, 145.7528 +9520, 66.26041, 125.1086 +9521, 67.44271, 142.4967 +9522, 68.68327, 139.7883 +9523, 67.58574, 125.2951 +9524, 66.55002, 111.2059 +9525, 66.3369, 148.2612 +9526, 67.59753, 132.7081 +9527, 66.16875, 138.9486 +9528, 68.38972, 118.5898 +9529, 69.32992, 133.9886 +9530, 66.91635, 120.1121 +9531, 67.20178, 121.5752 +9532, 68.88096, 143.4448 +9533, 68.83944, 136.7053 +9534, 70.43032, 121.1569 +9535, 69.6312, 138.6313 +9536, 66.23915, 130.0533 +9537, 69.57833, 140.2363 +9538, 70.32551, 142.6363 +9539, 65.17576, 100.3741 +9540, 70.81253, 118.5751 +9541, 69.5776, 127.2639 +9542, 64.67472, 104.1077 +9543, 68.0986, 114.887 +9544, 69.48224, 135.7121 +9545, 69.19418, 122.8981 +9546, 68.58131, 135.3452 +9547, 68.46986, 143.989 +9548, 66.52275, 116.8098 +9549, 67.29478, 100.4477 +9550, 68.02127, 133.231 +9551, 69.55433, 120.3508 +9552, 70.55274, 144.0613 +9553, 69.43571, 107.0716 +9554, 67.22028, 119.5298 +9555, 64.65699, 111.5398 +9556, 69.51829, 138.9221 +9557, 65.09086, 115.2015 +9558, 66.86091, 124.2395 +9559, 68.59768, 107.0438 +9560, 71.01173, 146.3277 +9561, 71.34761, 129.5618 +9562, 67.74021, 121.2672 +9563, 71.61413, 145.0715 +9564, 68.84447, 120.2177 +9565, 66.83785, 128.0275 +9566, 66.13335, 119.3266 +9567, 65.79023, 123.2118 +9568, 68.73614, 140.187 +9569, 67.57879, 131.6685 +9570, 70.7638, 145.0962 +9571, 67.67495, 127.9568 +9572, 64.5197, 128.6015 +9573, 68.70418, 146.899 +9574, 68.20196, 113.2495 +9575, 68.50077, 117.3796 +9576, 68.18475, 131.2772 +9577, 67.31928, 128.0177 +9578, 69.94028, 148.8857 +9579, 67.49093, 141.5919 +9580, 66.51022, 109.6487 +9581, 70.54908, 132.7834 +9582, 68.31443, 134.8167 +9583, 69.56373, 134.7459 +9584, 69.69727, 125.7112 +9585, 67.72532, 132.9298 +9586, 66.87841, 138.0319 +9587, 68.40503, 151.6563 +9588, 68.11084, 120.446 +9589, 66.86782, 109.5053 +9590, 68.96376, 130.3361 +9591, 70.51308, 137.2445 +9592, 65.1844, 126.7683 +9593, 70.21546, 113.0231 +9594, 69.03164, 133.84 +9595, 66.14828, 93.75301 +9596, 70.63243, 136.9783 +9597, 63.92425, 119.5108 +9598, 67.93981, 126.2074 +9599, 68.94411, 120.0772 +9600, 66.17288, 112.4068 +9601, 68.1199, 143.5778 +9602, 68.01974, 136.8445 +9603, 64.16711, 112.8528 +9604, 69.01036, 140.9219 +9605, 68.91364, 129.5028 +9606, 66.44713, 136.0997 +9607, 65.61804, 129.5947 +9608, 69.11903, 122.9885 +9609, 70.28184, 140.9463 +9610, 66.73051, 114.8715 +9611, 66.72657, 135.0653 +9612, 68.80212, 124.2972 +9613, 69.02745, 121.9743 +9614, 66.62724, 133.8779 +9615, 67.97623, 134.8979 +9616, 65.11298, 124.4876 +9617, 67.89264, 129.4893 +9618, 68.64717, 124.6416 +9619, 65.14223, 130.2813 +9620, 68.65645, 124.6263 +9621, 67.83641, 135.3784 +9622, 67.51286, 133.072 +9623, 66.63689, 128.8981 +9624, 68.34852, 134.0701 +9625, 65.8678, 127.5491 +9626, 67.36679, 145.0907 +9627, 68.35562, 128.6526 +9628, 65.76876, 126.7595 +9629, 67.90471, 104.8685 +9630, 65.54889, 122.4253 +9631, 69.03026, 134.7709 +9632, 66.27542, 119.7849 +9633, 67.88791, 126.7626 +9634, 65.72184, 107.6977 +9635, 68.66079, 130.6653 +9636, 68.28397, 107.6837 +9637, 69.17713, 128.8322 +9638, 69.2558, 138.4302 +9639, 69.54643, 144.0828 +9640, 68.97883, 141.869 +9641, 69.23439, 151.4362 +9642, 66.67303, 129.5801 +9643, 66.16115, 133.9835 +9644, 67.43035, 131.9753 +9645, 65.90419, 123.7444 +9646, 67.25626, 114.1209 +9647, 67.83686, 132.5467 +9648, 70.19109, 133.1316 +9649, 66.31564, 126.0798 +9650, 67.66646, 117.2472 +9651, 67.7519, 131.9273 +9652, 68.3228, 113.167 +9653, 72.0803, 130.742 +9654, 68.78572, 128.277 +9655, 68.57754, 118.4883 +9656, 68.37308, 124.2885 +9657, 68.74512, 130.1937 +9658, 69.39088, 130.6716 +9659, 68.61933, 134.812 +9660, 67.23029, 121.3587 +9661, 68.49582, 138.0952 +9662, 69.30757, 145.4359 +9663, 65.61597, 118.6455 +9664, 68.09188, 129.8851 +9665, 67.7166, 122.6816 +9666, 67.4508, 115.9856 +9667, 67.13754, 119.8772 +9668, 64.14983, 106.4504 +9669, 67.65922, 135.9871 +9670, 68.28587, 137.0307 +9671, 65.54248, 122.9935 +9672, 68.82518, 154.7341 +9673, 72.12412, 146.2978 +9674, 67.61816, 122.4365 +9675, 68.49971, 137.8023 +9676, 71.21183, 131.1726 +9677, 71.15269, 133.2166 +9678, 70.31235, 132.5313 +9679, 70.26465, 113.4165 +9680, 65.49772, 130.9129 +9681, 68.06388, 117.0789 +9682, 68.71857, 132.3502 +9683, 69.47394, 159.8926 +9684, 68.27314, 125.3854 +9685, 67.57915, 113.2566 +9686, 68.60227, 130.4389 +9687, 67.10387, 144.1473 +9688, 67.37805, 125.1132 +9689, 70.82184, 159.3021 +9690, 69.13393, 125.6548 +9691, 68.31448, 129.3196 +9692, 64.06191, 109.7758 +9693, 68.21309, 121.3595 +9694, 66.36575, 130.7716 +9695, 70.73365, 119.0237 +9696, 69.35175, 129.1685 +9697, 66.25415, 125.563 +9698, 68.60712, 105.1285 +9699, 70.27709, 127.2297 +9700, 68.2473, 124.244 +9701, 66.9098, 129.5755 +9702, 66.56227, 117.7942 +9703, 68.91759, 128.5454 +9704, 68.80671, 141.7393 +9705, 70.88619, 127.9719 +9706, 73.51383, 138.9321 +9707, 68.56821, 131.7526 +9708, 66.88985, 129.5218 +9709, 69.76635, 146.4205 +9710, 67.44905, 131.1587 +9711, 69.3961, 112.2049 +9712, 69.11016, 120.8271 +9713, 67.00457, 139.3125 +9714, 66.53958, 132.7218 +9715, 70.31894, 147.0394 +9716, 69.95672, 119.7538 +9717, 67.17704, 127.8719 +9718, 73.18256, 132.9995 +9719, 68.17989, 116.2537 +9720, 70.85706, 123.5573 +9721, 68.61586, 117.3901 +9722, 69.99675, 131.242 +9723, 66.89348, 156.4495 +9724, 68.944, 129.6552 +9725, 67.5559, 115.2974 +9726, 68.51482, 124.1914 +9727, 71.15411, 151.4754 +9728, 68.88473, 126.2634 +9729, 70.48065, 145.9294 +9730, 67.04825, 124.6696 +9731, 63.92053, 98.7457 +9732, 65.42959, 120.5649 +9733, 67.06764, 152.4888 +9734, 69.86922, 136.3855 +9735, 66.15786, 134.1293 +9736, 63.92128, 113.4515 +9737, 68.65125, 146.1165 +9738, 69.85696, 138.1103 +9739, 68.94991, 126.8747 +9740, 66.61559, 128.5193 +9741, 68.9697, 110.5576 +9742, 64.96032, 128.2809 +9743, 68.71059, 110.049 +9744, 67.44021, 129.2538 +9745, 69.29564, 125.0373 +9746, 68.3902, 116.4848 +9747, 65.57747, 117.9638 +9748, 68.16834, 129.595 +9749, 64.13237, 124.2891 +9750, 69.05347, 140.6226 +9751, 68.4964, 133.8031 +9752, 66.60332, 125.173 +9753, 66.78141, 115.7559 +9754, 68.68124, 112.327 +9755, 69.25972, 125.5782 +9756, 64.27481, 107.569 +9757, 70.17795, 132.6043 +9758, 69.75895, 139.3178 +9759, 67.61169, 140.8895 +9760, 71.41635, 146.9978 +9761, 68.70158, 120.3307 +9762, 65.38354, 123.2058 +9763, 71.82386, 136.6557 +9764, 65.44204, 128.948 +9765, 68.73343, 145.1099 +9766, 68.17608, 119.5684 +9767, 72.05521, 136.6193 +9768, 67.37648, 110.3445 +9769, 66.63165, 130.7607 +9770, 66.57454, 117.2413 +9771, 70.2814, 148.7963 +9772, 67.95765, 125.4817 +9773, 68.03122, 124.7968 +9774, 66.2195, 106.072 +9775, 70.60482, 134.8661 +9776, 67.43065, 130.2342 +9777, 65.90857, 122.1085 +9778, 72.47921, 138.4836 +9779, 66.5789, 116.9757 +9780, 67.04159, 128.5194 +9781, 65.89776, 139.6527 +9782, 66.02355, 104.0173 +9783, 70.6596, 131.0931 +9784, 69.32015, 133.3684 +9785, 68.46611, 118.6156 +9786, 68.1011, 118.9991 +9787, 69.10355, 131.272 +9788, 68.98767, 124.1313 +9789, 66.98612, 98.47799 +9790, 68.07886, 138.9164 +9791, 67.14062, 131.6581 +9792, 65.50185, 128.1924 +9793, 68.42655, 146.6355 +9794, 67.80423, 110.0665 +9795, 67.00515, 115.8675 +9796, 70.12939, 127.1045 +9797, 71.59767, 131.6252 +9798, 67.47799, 111.0157 +9799, 69.75215, 151.263 +9800, 70.2609, 124.2768 +9801, 68.46374, 128.6835 +9802, 66.49929, 113.3252 +9803, 68.77449, 147.9795 +9804, 67.53213, 132.3461 +9805, 71.32762, 132.2853 +9806, 69.54265, 132.2717 +9807, 68.84469, 137.642 +9808, 68.45131, 117.7085 +9809, 67.58396, 128.4773 +9810, 68.84619, 119.7516 +9811, 69.41444, 118.391 +9812, 69.85771, 120.8858 +9813, 66.09467, 115.8339 +9814, 68.69118, 118.5151 +9815, 66.91649, 120.891 +9816, 68.61516, 135.9551 +9817, 71.12975, 134.8375 +9818, 68.85924, 115.4611 +9819, 70.58611, 136.1071 +9820, 70.45602, 137.7117 +9821, 65.82729, 109.0839 +9822, 65.53454, 106.9057 +9823, 66.18249, 131.9705 +9824, 71.61882, 165.8716 +9825, 66.95769, 128.7377 +9826, 69.17434, 117.2939 +9827, 70.74903, 138.9422 +9828, 67.5619, 126.5968 +9829, 67.98909, 107.9762 +9830, 66.51309, 108.3641 +9831, 68.42597, 147.0716 +9832, 69.43903, 145.7242 +9833, 68.77366, 140.1915 +9834, 67.44207, 131.3793 +9835, 71.55011, 141.6604 +9836, 70.1884, 123.7339 +9837, 65.2831, 100.0283 +9838, 70.74713, 146.572 +9839, 69.73095, 145.2295 +9840, 68.86778, 126.558 +9841, 68.39148, 151.9512 +9842, 67.41403, 128.8079 +9843, 65.04265, 126.6868 +9844, 68.77248, 136.0577 +9845, 69.84344, 122.7778 +9846, 63.93049, 108.3559 +9847, 70.31106, 147.7541 +9848, 67.98819, 123.2582 +9849, 70.81754, 130.6455 +9850, 68.38637, 124.6679 +9851, 68.22631, 125.5255 +9852, 65.89874, 114.3292 +9853, 69.73748, 145.8184 +9854, 68.42911, 132.0335 +9855, 67.15172, 141.4995 +9856, 67.18709, 125.5079 +9857, 70.49324, 121.4159 +9858, 69.89967, 126.9552 +9859, 68.57785, 120.5832 +9860, 67.44754, 132.5691 +9861, 68.27063, 119.3592 +9862, 68.02518, 116.9769 +9863, 64.47165, 110.3828 +9864, 70.43528, 124.8658 +9865, 70.38848, 135.0006 +9866, 68.9876, 157.8304 +9867, 70.53, 145.5456 +9868, 70.77882, 123.2178 +9869, 68.03476, 131.787 +9870, 66.03888, 127.3603 +9871, 67.24661, 128.9941 +9872, 66.34444, 121.7823 +9873, 68.00358, 126.2625 +9874, 67.5354, 131.3948 +9875, 66.26621, 108.9546 +9876, 69.34812, 136.3244 +9877, 61.30021, 120.8819 +9878, 63.85336, 116.1584 +9879, 67.79112, 122.7668 +9880, 68.84082, 117.168 +9881, 67.23541, 128.9174 +9882, 72.0041, 138.0863 +9883, 69.37103, 127.227 +9884, 66.95564, 137.1765 +9885, 66.45619, 109.9414 +9886, 68.13655, 134.1517 +9887, 66.67832, 113.69 +9888, 69.28115, 141.7671 +9889, 70.62015, 140.458 +9890, 67.99465, 119.7749 +9891, 68.48033, 130.2865 +9892, 69.06455, 141.4252 +9893, 71.75345, 125.4749 +9894, 68.12333, 142.4333 +9895, 69.27301, 139.802 +9896, 70.6871, 132.7199 +9897, 71.59803, 118.0366 +9898, 69.19962, 132.039 +9899, 68.50734, 138.7054 +9900, 67.31358, 118.7559 +9901, 69.35559, 132.2083 +9902, 68.04018, 123.4858 +9903, 69.43599, 127.4407 +9904, 68.11666, 122.9518 +9905, 70.38735, 115.9033 +9906, 67.68927, 117.8434 +9907, 70.10753, 106.1532 +9908, 65.63803, 138.7008 +9909, 66.1331, 131.333 +9910, 67.98396, 139.0779 +9911, 70.00086, 145.8357 +9912, 68.77748, 138.6318 +9913, 69.55778, 136.8985 +9914, 69.64354, 141.6881 +9915, 67.51477, 122.6746 +9916, 66.32547, 109.4408 +9917, 68.11857, 123.5801 +9918, 68.95567, 139.0009 +9919, 69.47262, 159.961 +9920, 67.36852, 133.0522 +9921, 69.49484, 129.154 +9922, 65.21743, 130.2571 +9923, 66.44053, 126.5657 +9924, 67.4008, 111.4315 +9925, 70.05188, 136.1694 +9926, 70.47453, 165.815 +9927, 67.62136, 144.3461 +9928, 71.26378, 147.7777 +9929, 69.11384, 134.8827 +9930, 69.13058, 144.5313 +9931, 71.76731, 145.2951 +9932, 71.90517, 131.6109 +9933, 68.61716, 129.5184 +9934, 66.30375, 120.6304 +9935, 69.47578, 133.7738 +9936, 67.82661, 121.302 +9937, 66.40842, 127.5827 +9938, 69.29497, 140.665 +9939, 67.41872, 113.2182 +9940, 68.30044, 125.6614 +9941, 69.69323, 139.8444 +9942, 66.87896, 119.345 +9943, 67.917, 123.5503 +9944, 68.80858, 122.5048 +9945, 71.0785, 148.6654 +9946, 68.50032, 126.3782 +9947, 68.32165, 134.6888 +9948, 67.44148, 118.7423 +9949, 67.4694, 119.622 +9950, 68.57565, 144.6492 +9951, 69.90495, 131.2178 +9952, 69.06563, 133.1598 +9953, 66.36602, 101.9583 +9954, 68.08525, 137.6375 +9955, 69.76408, 132.5028 +9956, 68.09437, 122.4897 +9957, 67.77372, 120.8679 +9958, 73.1771, 162.3663 +9959, 70.8932, 137.9685 +9960, 66.59118, 133.313 +9961, 68.84406, 121.8554 +9962, 67.82525, 120.6637 +9963, 67.4964, 144.1456 +9964, 66.9367, 110.3082 +9965, 68.73832, 136.5058 +9966, 67.82175, 133.7939 +9967, 67.40266, 125.4416 +9968, 71.91481, 151.3634 +9969, 66.00315, 115.9391 +9970, 66.23591, 122.6684 +9971, 66.05033, 129.398 +9972, 68.59833, 131.3191 +9973, 66.73802, 146.5547 +9974, 68.95236, 130.8332 +9975, 66.8636, 134.6229 +9976, 63.54215, 106.5463 +9977, 68.29415, 126.4078 +9978, 67.18456, 155.58 +9979, 66.93941, 128.5959 +9980, 67.39381, 129.645 +9981, 70.10564, 137.8281 +9982, 67.00791, 114.4926 +9983, 68.00661, 112.832 +9984, 64.75128, 96.50653 +9985, 64.75712, 117.9964 +9986, 65.55869, 104.1268 +9987, 67.94061, 101.9043 +9988, 66.32718, 112.5542 +9989, 67.76335, 130.3666 +9990, 68.84705, 143.2721 +9991, 66.22794, 114.482 +9992, 67.33307, 131.244 +9993, 68.16808, 129.6398 +9994, 66.9724, 123.0562 +9995, 69.16053, 127.6593 +9996, 67.96769, 124.3206 +9997, 71.39143, 128.9603 +9998, 69.17936, 142.5122 +9999, 67.63262, 108.6316 +10000, 68.13844, 133.3492 +10001, 68.57515, 132.9664 +10002, 69.27082, 123.9376 +10003, 68.03694, 129.7161 +10004, 66.78394, 128.5766 +10005, 68.37086, 121.5928 +10006, 69.06702, 125.2812 +10007, 68.68835, 120.2494 +10008, 67.94587, 127.063 +10009, 69.97069, 130.5886 +10010, 67.83678, 130.1037 +10011, 66.57079, 122.6824 +10012, 69.93637, 136.028 +10013, 65.68971, 116.112 +10014, 68.09276, 136.1992 +10015, 68.51531, 149.8957 +10016, 68.66816, 129.1077 +10017, 70.74635, 128.3355 +10018, 68.93456, 134.2009 +10019, 64.55693, 115.8225 +10020, 66.63381, 110.4108 +10021, 66.02983, 125.4093 +10022, 71.83894, 128.1898 +10023, 69.11329, 132.1717 +10024, 68.72609, 126.9163 +10025, 67.67278, 140.825 +10026, 67.97403, 115.5281 +10027, 66.28867, 96.43706 +10028, 66.78936, 126.941 +10029, 70.42997, 130.1329 +10030, 67.34451, 128.3837 +10031, 66.55225, 115.0221 +10032, 67.54453, 116.9754 +10033, 67.11135, 121.9965 +10034, 66.39139, 120.8401 +10035, 70.1004, 143.8223 +10036, 66.29079, 129.0103 +10037, 66.82271, 122.2173 +10038, 68.81388, 141.3748 +10039, 70.7395, 118.7482 +10040, 68.56268, 110.8342 +10041, 66.80278, 110.5325 +10042, 64.49508, 109.748 +10043, 68.00244, 139.8746 +10044, 68.14281, 144.8232 +10045, 66.9929, 112.8264 +10046, 65.95458, 117.0548 +10047, 71.14826, 117.7951 +10048, 69.26366, 143.5924 +10049, 65.33361, 113.766 +10050, 68.07198, 139.8559 +10051, 68.75607, 127.0394 +10052, 68.25481, 122.3093 +10053, 67.6301, 126.2598 +10054, 66.76358, 116.2435 +10055, 68.44489, 122.5856 +10056, 68.6443, 137.6504 +10057, 69.7314, 144.728 +10058, 68.04736, 126.1972 +10059, 66.8011, 114.0278 +10060, 67.31382, 114.2178 +10061, 65.94149, 100.0924 +10062, 68.04148, 113.2556 +10063, 65.76389, 121.5449 +10064, 69.98217, 138.5123 +10065, 66.53339, 124.0166 +10066, 67.30571, 118.2689 +10067, 71.37779, 128.3741 +10068, 65.41261, 106.923 +10069, 69.9379, 127.7381 +10070, 70.94031, 129.7535 +10071, 66.48588, 135.3436 +10072, 70.59467, 122.6572 +10073, 69.26749, 134.6498 +10074, 68.01553, 120.2336 +10075, 67.48435, 133.4493 +10076, 66.64515, 124.0263 +10077, 66.25306, 109.1716 +10078, 70.78006, 119.5972 +10079, 67.46565, 126.6369 +10080, 67.95071, 147.4028 +10081, 67.32652, 116.3942 +10082, 65.49287, 130.1238 +10083, 67.64989, 127.9459 +10084, 66.4175, 137.3847 +10085, 68.52361, 118.6287 +10086, 70.9931, 139.3241 +10087, 68.27507, 121.744 +10088, 68.72072, 118.7503 +10089, 68.14922, 122.1772 +10090, 66.32895, 120.6915 +10091, 67.34775, 126.0878 +10092, 69.17835, 124.8283 +10093, 67.72085, 135.3916 +10094, 67.78477, 132.7538 +10095, 64.52209, 128.4876 +10096, 68.67602, 130.5971 +10097, 65.24442, 109.9482 +10098, 65.99271, 124.0657 +10099, 68.60453, 126.4562 +10100, 64.62503, 115.5461 +10101, 67.63678, 130.1742 +10102, 70.36634, 153.457 +10103, 68.7096, 143.9246 +10104, 66.73859, 128.1908 +10105, 65.80323, 121.9802 +10106, 65.01409, 133.769 +10107, 67.50667, 121.3548 +10108, 67.70298, 121.7608 +10109, 68.18064, 133.3395 +10110, 67.08054, 134.2481 +10111, 66.53602, 133.3901 +10112, 70.85159, 155.4236 +10113, 65.99732, 132.6291 +10114, 69.65644, 128.9009 +10115, 64.36495, 113.6952 +10116, 68.51561, 122.5108 +10117, 67.01001, 132.9762 +10118, 68.65082, 122.8115 +10119, 70.11761, 120.1837 +10120, 67.66432, 114.333 +10121, 67.54436, 117.0024 +10122, 69.24622, 135.6679 +10123, 64.70908, 119.9401 +10124, 67.77202, 118.5771 +10125, 67.88823, 138.9753 +10126, 69.54154, 125.8526 +10127, 69.92873, 127.9198 +10128, 69.47751, 135.3065 +10129, 67.55945, 127.4039 +10130, 67.83063, 132.731 +10131, 71.63342, 133.7823 +10132, 66.93561, 126.6451 +10133, 66.40984, 115.8011 +10134, 67.25458, 126.4183 +10135, 67.42176, 119.9688 +10136, 66.89243, 119.7186 +10137, 64.41136, 124.1027 +10138, 68.08186, 119.4421 +10139, 68.73489, 121.9388 +10140, 66.84196, 129.2855 +10141, 66.38618, 124.5214 +10142, 65.80415, 130.1618 +10143, 65.57517, 122.5124 +10144, 68.65405, 140.5776 +10145, 65.51063, 126.527 +10146, 70.83038, 133.8104 +10147, 65.4054, 129.794 +10148, 71.85374, 130.9334 +10149, 65.69257, 124.2145 +10150, 64.50068, 114.1913 +10151, 67.32663, 142.5938 +10152, 68.82231, 137.0983 +10153, 68.31438, 138.8053 +10154, 68.89476, 135.4686 +10155, 68.45037, 122.0752 +10156, 70.38299, 131.0126 +10157, 66.77655, 131.643 +10158, 70.61416, 127.9027 +10159, 67.99636, 150.304 +10160, 63.91795, 126.4849 +10161, 69.08168, 123.5754 +10162, 67.94687, 134.417 +10163, 66.41264, 141.9618 +10164, 68.4113, 114.6332 +10165, 69.17467, 132.8267 +10166, 68.80945, 126.7765 +10167, 67.98949, 130.0852 +10168, 67.47425, 120.9892 +10169, 69.37637, 140.4862 +10170, 66.7457, 119.6273 +10171, 71.81042, 146.3814 +10172, 68.49779, 128.8718 +10173, 66.22373, 124.7247 +10174, 68.48338, 127.7586 +10175, 67.48748, 129.8294 +10176, 66.80122, 124.956 +10177, 69.36031, 117.2519 +10178, 69.44113, 134.5996 +10179, 68.02891, 119.5087 +10180, 65.4401, 105.3289 +10181, 68.05522, 130.0591 +10182, 65.44861, 120.9266 +10183, 69.01128, 130.4463 +10184, 66.13501, 107.8115 +10185, 65.43462, 115.348 +10186, 67.70555, 121.7045 +10187, 72.00385, 126.9701 +10188, 68.22827, 122.7364 +10189, 67.97769, 132.02 +10190, 69.6181, 138.8191 +10191, 71.23192, 131.4701 +10192, 66.21527, 125.8998 +10193, 69.46816, 130.0392 +10194, 67.16775, 118.855 +10195, 67.92821, 140.6105 +10196, 68.02041, 120.0773 +10197, 63.16568, 101.9022 +10198, 67.43271, 113.1315 +10199, 67.57909, 148.2058 +10200, 69.34236, 130.11 +10201, 69.03935, 128.1055 +10202, 66.5898, 126.9651 +10203, 67.04732, 142.3191 +10204, 70.93771, 134.4353 +10205, 66.26707, 100.585 +10206, 66.61921, 121.9217 +10207, 68.54554, 123.1625 +10208, 71.27733, 126.1745 +10209, 68.28034, 122.7293 +10210, 70.04241, 149.3332 +10211, 68.7644, 123.3415 +10212, 70.09987, 135.2847 +10213, 70.42506, 136.6994 +10214, 66.84364, 119.8992 +10215, 70.89055, 138.6481 +10216, 71.60107, 138.3052 +10217, 65.51369, 130.2502 +10218, 66.99057, 106.9839 +10219, 68.35139, 112.8812 +10220, 67.39169, 131.0616 +10221, 68.985, 127.1889 +10222, 66.60289, 136.9817 +10223, 68.2832, 124.3849 +10224, 65.51929, 105.4043 +10225, 71.86969, 142.1276 +10226, 66.19577, 126.6438 +10227, 66.98863, 132.0612 +10228, 64.22788, 120.3019 +10229, 69.09806, 138.3934 +10230, 68.00458, 135.4125 +10231, 68.277, 135.3096 +10232, 71.698, 147.4595 +10233, 67.06982, 104.1591 +10234, 66.98454, 130.183 +10235, 70.71295, 170.924 +10236, 66.30287, 137.6953 +10237, 68.78265, 126.7758 +10238, 69.2984, 121.2638 +10239, 68.03691, 107.9584 +10240, 67.27286, 141.7463 +10241, 61.93152, 85.2904 +10242, 68.44672, 134.0838 +10243, 65.52171, 121.4215 +10244, 68.73061, 123.9749 +10245, 70.32188, 119.7992 +10246, 70.72616, 136.5876 +10247, 67.23886, 142.0396 +10248, 67.42973, 115.9108 +10249, 66.44447, 119.4981 +10250, 65.92998, 112.2153 +10251, 68.45982, 123.3502 +10252, 69.43594, 134.1796 +10253, 65.32774, 121.3348 +10254, 67.30054, 126.6744 +10255, 67.6736, 125.3719 +10256, 67.76707, 114.1675 +10257, 66.39375, 121.5455 +10258, 70.14848, 116.3663 +10259, 67.81882, 129.6804 +10260, 68.92743, 129.8436 +10261, 69.97517, 135.5642 +10262, 65.96101, 117.1969 +10263, 68.8375, 128.1107 +10264, 67.46994, 121.8602 +10265, 65.67254, 132.8915 +10266, 72.42515, 129.0739 +10267, 66.33452, 127.956 +10268, 68.16377, 145.4734 +10269, 68.80719, 142.8541 +10270, 67.89934, 117.397 +10271, 69.75835, 122.7009 +10272, 67.65443, 133.8413 +10273, 66.06129, 132.3972 +10274, 68.07253, 134.6856 +10275, 65.00025, 118.8709 +10276, 67.95845, 127.4662 +10277, 68.88694, 122.875 +10278, 65.41879, 120.3438 +10279, 68.1777, 120.0616 +10280, 70.3772, 126.5767 +10281, 68.11999, 116.4353 +10282, 68.35276, 124.8255 +10283, 69.42068, 131.768 +10284, 67.65704, 104.6366 +10285, 67.9709, 133.9997 +10286, 65.89416, 113.7654 +10287, 67.92834, 129.1861 +10288, 67.67419, 133.0796 +10289, 67.17717, 112.4891 +10290, 70.64743, 122.3352 +10291, 71.01751, 130.6425 +10292, 65.9993, 115.9772 +10293, 66.66578, 128.0432 +10294, 64.56593, 102.0383 +10295, 64.96159, 107.4868 +10296, 68.93317, 126.2217 +10297, 68.6422, 138.0343 +10298, 68.77736, 154.8517 +10299, 66.67804, 139.1714 +10300, 67.99234, 133.4281 +10301, 67.73219, 120.8693 +10302, 68.88114, 127.9823 +10303, 67.81179, 142.3762 +10304, 72.26487, 136.5009 +10305, 70.06893, 117.0553 +10306, 66.14966, 131.4211 +10307, 68.69605, 133.577 +10308, 68.47571, 131.9537 +10309, 68.37802, 119.9539 +10310, 68.87878, 119.3971 +10311, 65.80924, 112.8845 +10312, 69.2799, 152.5435 +10313, 67.01129, 127.7649 +10314, 68.20847, 112.9406 +10315, 68.68965, 134.1251 +10316, 66.05144, 119.3036 +10317, 69.09455, 127.3372 +10318, 68.86576, 112.7935 +10319, 67.87248, 127.7199 +10320, 67.02254, 114.1688 +10321, 64.26864, 112.2987 +10322, 69.22231, 127.7632 +10323, 69.18516, 115.089 +10324, 69.28583, 146.5881 +10325, 67.54616, 128.8973 +10326, 67.27501, 155.8189 +10327, 68.14682, 124.0938 +10328, 68.11154, 119.0578 +10329, 68.00907, 145.3193 +10330, 66.10884, 127.8689 +10331, 74.36328, 164.6643 +10332, 69.87349, 137.2025 +10333, 64.30282, 118.0081 +10334, 68.1745, 154.0079 +10335, 68.00916, 125.3284 +10336, 68.13485, 119.87 +10337, 66.8495, 110.174 +10338, 68.04704, 131.5455 +10339, 68.95045, 129.1584 +10340, 67.56709, 112.434 +10341, 66.34841, 109.9387 +10342, 67.87075, 135.8476 +10343, 67.06849, 118.8617 +10344, 67.23477, 114.1638 +10345, 69.6254, 131.1821 +10346, 66.96018, 134.7602 +10347, 68.90732, 144.3025 +10348, 71.60814, 144.5143 +10349, 65.20502, 118.2572 +10350, 67.72312, 123.8437 +10351, 65.36188, 117.1863 +10352, 71.26753, 125.0196 +10353, 65.11686, 117.0472 +10354, 71.23323, 145.6988 +10355, 66.98585, 109.8113 +10356, 68.98353, 127.9516 +10357, 67.07174, 126.4042 +10358, 69.87863, 141.4678 +10359, 66.15177, 111.9139 +10360, 67.17694, 120.6343 +10361, 66.65138, 111.267 +10362, 67.02613, 131.52 +10363, 69.05469, 134.6582 +10364, 70.30558, 130.5531 +10365, 69.15782, 137.8314 +10366, 67.70344, 108.9052 +10367, 68.77537, 138.0502 +10368, 68.18873, 127.1719 +10369, 67.00131, 129.8178 +10370, 72.68545, 124.1497 +10371, 67.1693, 126.4281 +10372, 68.52314, 146.2621 +10373, 65.75194, 116.2159 +10374, 69.40466, 127.6167 +10375, 67.27594, 131.5767 +10376, 66.33031, 118.3779 +10377, 66.81347, 121.6926 +10378, 68.20959, 128.8569 +10379, 66.85651, 105.9897 +10380, 68.28564, 123.0402 +10381, 68.86183, 134.6779 +10382, 70.22727, 120.4772 +10383, 68.51085, 125.3584 +10384, 68.12993, 108.1225 +10385, 67.45958, 133.6881 +10386, 67.95057, 132.93 +10387, 70.41003, 132.8924 +10388, 68.82861, 132.9931 +10389, 70.88474, 132.2668 +10390, 70.23488, 131.4445 +10391, 65.12636, 122.1146 +10392, 70.7406, 128.0491 +10393, 68.1794, 126.5975 +10394, 66.28166, 132.7775 +10395, 68.59748, 135.9033 +10396, 66.23597, 119.438 +10397, 67.42763, 112.0482 +10398, 70.93428, 134.7475 +10399, 68.2984, 121.2823 +10400, 66.51911, 135.1788 +10401, 67.50653, 126.2248 +10402, 71.31381, 144.7622 +10403, 67.86603, 137.0526 +10404, 68.4164, 127.039 +10405, 70.70831, 132.575 +10406, 67.2978, 98.74301 +10407, 66.98357, 120.0619 +10408, 65.73548, 135.6257 +10409, 63.46952, 109.7989 +10410, 72.31104, 152.7759 +10411, 66.5271, 126.2462 +10412, 65.98844, 129.6398 +10413, 65.54355, 114.8749 +10414, 69.63987, 126.6245 +10415, 69.35826, 133.0021 +10416, 67.58203, 107.7908 +10417, 70.18844, 131.0572 +10418, 67.913, 131.565 +10419, 65.9935, 116.3407 +10420, 68.45079, 127.9629 +10421, 67.8761, 132.2874 +10422, 68.20301, 122.2456 +10423, 68.02558, 121.6909 +10424, 70.11194, 130.6004 +10425, 69.95523, 145.4424 +10426, 70.2156, 147.6645 +10427, 70.92745, 129.8921 +10428, 64.90177, 111.0552 +10429, 65.83748, 120.8376 +10430, 67.36794, 131.8412 +10431, 65.16759, 127.1526 +10432, 65.57954, 121.4738 +10433, 69.5881, 128.133 +10434, 69.20122, 139.1962 +10435, 68.24975, 138.9947 +10436, 70.38081, 133.4191 +10437, 68.32966, 133.8127 +10438, 64.35599, 133.6729 +10439, 66.98202, 120.6984 +10440, 69.39666, 126.7731 +10441, 66.24724, 99.07691 +10442, 70.81716, 137.0278 +10443, 72.21471, 135.0052 +10444, 69.06657, 142.6149 +10445, 70.86115, 130.7419 +10446, 73.33584, 133.4109 +10447, 69.71521, 133.5603 +10448, 68.7218, 134.5512 +10449, 70.15159, 143.2453 +10450, 71.07028, 128.1241 +10451, 68.77062, 145.2039 +10452, 69.30497, 114.185 +10453, 69.12822, 147.1321 +10454, 68.91395, 132.5095 +10455, 67.71189, 129.3881 +10456, 63.00544, 116.1438 +10457, 68.7807, 128.5783 +10458, 63.02884, 96.47744 +10459, 68.89673, 136.2149 +10460, 66.21931, 132.252 +10461, 68.06832, 141.576 +10462, 67.57157, 128.3205 +10463, 66.11571, 136.9935 +10464, 66.22051, 106.2064 +10465, 64.08406, 111.7218 +10466, 66.77064, 108.8598 +10467, 67.33892, 133.2337 +10468, 65.75905, 140.6289 +10469, 69.00995, 141.837 +10470, 69.17655, 139.7818 +10471, 65.96052, 102.3802 +10472, 64.14294, 115.0981 +10473, 67.01845, 119.8016 +10474, 68.14749, 128.0245 +10475, 67.35561, 119.2536 +10476, 66.94659, 129.5847 +10477, 69.23785, 124.8157 +10478, 64.77966, 89.64885 +10479, 69.54866, 125.9774 +10480, 68.95676, 124.3441 +10481, 68.80266, 138.0014 +10482, 69.31999, 131.6757 +10483, 72.35849, 139.2038 +10484, 66.13184, 118.5572 +10485, 67.77688, 117.444 +10486, 68.65699, 107.8873 +10487, 67.91922, 131.6555 +10488, 70.34445, 131.6005 +10489, 71.06425, 152.8456 +10490, 68.3927, 123.4257 +10491, 66.79712, 131.5125 +10492, 64.93783, 103.7577 +10493, 70.14231, 117.884 +10494, 64.00875, 104.3435 +10495, 69.51978, 129.9665 +10496, 66.94273, 117.6676 +10497, 70.87794, 149.1428 +10498, 65.24649, 116.9904 +10499, 69.49131, 126.0984 +10500, 68.08959, 128.0709 +10501, 70.65463, 149.4745 +10502, 64.93386, 96.67888 +10503, 68.70534, 124.5106 +10504, 67.11498, 119.0296 +10505, 70.00068, 140.9303 +10506, 72.37892, 156.8464 +10507, 68.172, 115.1333 +10508, 67.24574, 135.0178 +10509, 66.04961, 127.901 +10510, 64.85955, 115.5248 +10511, 69.52955, 130.5978 +10512, 68.82408, 132.1751 +10513, 69.41921, 137.9209 +10514, 69.05841, 111.3935 +10515, 68.89369, 119.6711 +10516, 68.73216, 130.2555 +10517, 69.49069, 132.1774 +10518, 64.10059, 121.0721 +10519, 68.30462, 142.3127 +10520, 68.71525, 114.003 +10521, 65.69719, 107.6348 +10522, 68.09404, 115.4798 +10523, 66.51622, 135.7521 +10524, 68.52534, 133.3322 +10525, 69.20887, 135.9792 +10526, 67.70321, 120.999 +10527, 68.15955, 130.7498 +10528, 67.18814, 106.7904 +10529, 68.50904, 119.4901 +10530, 66.51943, 138.5418 +10531, 66.27868, 115.6044 +10532, 67.47904, 114.978 +10533, 67.17176, 134.8531 +10534, 70.21021, 141.9264 +10535, 66.48457, 113.2493 +10536, 67.38335, 139.6947 +10537, 69.63142, 147.2102 +10538, 69.05892, 145.238 +10539, 67.73576, 99.74502 +10540, 68.0427, 127.537 +10541, 70.50652, 143.0547 +10542, 68.61607, 122.2814 +10543, 70.54593, 142.2969 +10544, 65.89082, 118.0925 +10545, 71.21608, 157.4503 +10546, 68.20518, 114.4749 +10547, 67.74012, 138.1428 +10548, 66.26527, 110.327 +10549, 65.53319, 105.8284 +10550, 66.51322, 113.1916 +10551, 67.35638, 131.4344 +10552, 70.30591, 133.8064 +10553, 67.04142, 112.9803 +10554, 67.7369, 110.5975 +10555, 69.66034, 140.415 +10556, 69.98999, 148.9512 +10557, 66.79277, 127.3793 +10558, 66.00918, 133.9975 +10559, 66.62111, 130.0858 +10560, 69.74276, 132.0686 +10561, 66.16467, 131.0357 +10562, 70.20538, 132.2909 +10563, 68.60463, 135.4929 +10564, 70.62429, 111.8873 +10565, 66.94547, 119.7758 +10566, 70.34761, 121.937 +10567, 65.49205, 108.3441 +10568, 68.89339, 128.0101 +10569, 66.19965, 125.1485 +10570, 66.36441, 123.1231 +10571, 66.77807, 137.3777 +10572, 68.09728, 120.4912 +10573, 68.22134, 149.196 +10574, 70.09705, 139.6371 +10575, 72.1712, 128.1616 +10576, 68.84442, 143.5309 +10577, 69.66256, 136.6815 +10578, 68.7237, 132.2889 +10579, 65.52882, 129.2356 +10580, 70.69497, 127.5854 +10581, 67.00435, 119.8816 +10582, 67.55287, 121.7881 +10583, 68.9392, 118.0553 +10584, 66.89064, 129.4493 +10585, 66.87923, 132.1593 +10586, 69.27991, 130.8975 +10587, 68.63068, 112.5824 +10588, 66.02106, 134.9502 +10589, 67.31835, 126.3568 +10590, 70.64068, 121.9356 +10591, 66.5818, 131.6912 +10592, 66.24792, 126.2204 +10593, 65.96918, 126.7294 +10594, 66.08834, 130.1595 +10595, 68.74671, 126.0762 +10596, 68.38332, 152.4418 +10597, 64.73972, 122.4279 +10598, 68.56976, 135.6351 +10599, 67.50394, 124.7759 +10600, 69.83182, 132.6278 +10601, 66.93919, 131.6494 +10602, 67.87115, 117.8922 +10603, 66.38765, 127.8206 +10604, 66.71594, 114.609 +10605, 69.92883, 160.4871 +10606, 65.60065, 116.6834 +10607, 68.94104, 132.7443 +10608, 67.35421, 116.3161 +10609, 69.2689, 126.223 +10610, 64.78382, 124.4218 +10611, 69.00289, 131.0501 +10612, 67.94108, 149.5679 +10613, 69.77799, 127.8931 +10614, 68.26272, 127.9975 +10615, 68.02075, 131.2079 +10616, 69.04822, 113.5618 +10617, 67.98576, 137.0912 +10618, 63.50795, 114.8749 +10619, 69.56909, 127.9663 +10620, 69.10658, 119.2041 +10621, 69.17856, 134.1517 +10622, 67.06151, 120.7166 +10623, 70.89432, 131.7651 +10624, 69.36734, 137.5629 +10625, 66.55432, 124.5989 +10626, 68.00765, 129.6789 +10627, 67.29039, 115.1226 +10628, 66.88356, 118.4508 +10629, 73.22072, 137.0768 +10630, 66.95094, 128.8915 +10631, 65.93861, 117.8413 +10632, 68.06028, 98.9001 +10633, 65.9792, 140.0098 +10634, 69.32477, 138.604 +10635, 68.01965, 116.1544 +10636, 73.88574, 135.9816 +10637, 68.7284, 128.3036 +10638, 66.98669, 129.6223 +10639, 67.65185, 147.7052 +10640, 66.73298, 138.5239 +10641, 67.57886, 105.3225 +10642, 70.88703, 139.6806 +10643, 68.64071, 134.5343 +10644, 66.38501, 128.8816 +10645, 67.74524, 128.6228 +10646, 69.42469, 137.1312 +10647, 64.21102, 113.6698 +10648, 69.04355, 135.6615 +10649, 68.44013, 143.8953 +10650, 69.86939, 123.235 +10651, 67.27641, 112.1723 +10652, 69.26705, 121.2725 +10653, 65.83018, 129.2681 +10654, 66.56855, 129.3466 +10655, 66.89784, 137.6947 +10656, 69.58798, 113.665 +10657, 69.61101, 136.2898 +10658, 67.90062, 136.0332 +10659, 66.4422, 129.4758 +10660, 70.1338, 134.4689 +10661, 67.24137, 134.0858 +10662, 71.40024, 118.804 +10663, 68.81761, 116.5307 +10664, 66.00638, 120.3 +10665, 66.82919, 125.1578 +10666, 66.77789, 123.6758 +10667, 64.55809, 113.8706 +10668, 67.49962, 137.1728 +10669, 72.09703, 134.2724 +10670, 71.48656, 105.5331 +10671, 67.70221, 130.5761 +10672, 69.02373, 114.3528 +10673, 66.73813, 119.0173 +10674, 64.09479, 107.0877 +10675, 69.55031, 115.7306 +10676, 67.28152, 131.3143 +10677, 70.83864, 142.2989 +10678, 65.30751, 119.7157 +10679, 68.17705, 126.0792 +10680, 67.49175, 109.8464 +10681, 67.69924, 123.8695 +10682, 68.89262, 138.0155 +10683, 66.69777, 121.1209 +10684, 68.02164, 131.326 +10685, 72.32382, 130.0773 +10686, 67.89736, 119.9817 +10687, 65.94463, 100.5898 +10688, 68.43859, 137.938 +10689, 68.34332, 129.9947 +10690, 67.50727, 112.6174 +10691, 65.73491, 115.5253 +10692, 68.45227, 122.7969 +10693, 68.09452, 112.6967 +10694, 66.87642, 111.7273 +10695, 68.78042, 118.6681 +10696, 67.76232, 117.16 +10697, 66.92622, 133.9616 +10698, 70.4839, 122.8518 +10699, 66.90481, 126.6455 +10700, 67.21178, 155.0082 +10701, 67.93338, 119.7698 +10702, 69.36009, 138.4303 +10703, 67.2037, 129.3922 +10704, 66.11772, 113.1732 +10705, 68.87141, 141.5641 +10706, 72.13664, 129.6934 +10707, 66.47378, 121.8011 +10708, 67.44181, 136.2936 +10709, 66.45604, 133.1168 +10710, 64.93446, 113.589 +10711, 71.13511, 151.4674 +10712, 68.14569, 130.1973 +10713, 69.80663, 131.1705 +10714, 69.09198, 126.1547 +10715, 70.73962, 141.7215 +10716, 69.69246, 135.3223 +10717, 67.18323, 137.3825 +10718, 70.75638, 123.4866 +10719, 70.79804, 125.7816 +10720, 67.59872, 128.558 +10721, 69.14817, 153.3639 +10722, 68.47791, 137.359 +10723, 71.2696, 145.0339 +10724, 69.58091, 131.7444 +10725, 67.99813, 118.223 +10726, 67.12516, 126.1205 +10727, 66.94553, 118.117 +10728, 69.35076, 141.2216 +10729, 68.86773, 136.9215 +10730, 67.19725, 136.8241 +10731, 66.15149, 123.9501 +10732, 67.66962, 135.2617 +10733, 63.29618, 111.4056 +10734, 71.77485, 145.7175 +10735, 70.76918, 134.8925 +10736, 65.76134, 110.0183 +10737, 69.57368, 136.346 +10738, 69.7701, 111.5563 +10739, 71.90393, 141.4574 +10740, 71.83818, 139.7878 +10741, 69.74181, 124.4227 +10742, 65.40817, 122.8072 +10743, 69.73609, 152.6969 +10744, 68.05785, 115.7184 +10745, 65.56584, 101.7955 +10746, 68.58632, 121.2848 +10747, 70.5479, 121.361 +10748, 68.62838, 116.4417 +10749, 67.30469, 125.7158 +10750, 67.86793, 132.4746 +10751, 68.18436, 111.6939 +10752, 67.12433, 123.5312 +10753, 67.50781, 127.5459 +10754, 69.74866, 136.4338 +10755, 65.94502, 119.3141 +10756, 66.03597, 116.2143 +10757, 66.74873, 136.2302 +10758, 69.30449, 118.5162 +10759, 69.05283, 144.8074 +10760, 68.50867, 133.9436 +10761, 66.63013, 118.1453 +10762, 68.67406, 124.6569 +10763, 69.93061, 138.8325 +10764, 69.11316, 151.1101 +10765, 67.21939, 132.8338 +10766, 68.94888, 115.6681 +10767, 71.6822, 138.0712 +10768, 67.7161, 120.4559 +10769, 66.04065, 129.7117 +10770, 69.56767, 129.7364 +10771, 67.04789, 136.4177 +10772, 66.11294, 104.4748 +10773, 67.56696, 117.3571 +10774, 68.2101, 119.4079 +10775, 69.0425, 127.1652 +10776, 65.20788, 132.5724 +10777, 66.56896, 135.5198 +10778, 69.09239, 144.5847 +10779, 67.34629, 118.7027 +10780, 67.37558, 120.6235 +10781, 69.39824, 138.4163 +10782, 69.52151, 145.1544 +10783, 68.78586, 139.9157 +10784, 66.75113, 111.2522 +10785, 65.84981, 136.9029 +10786, 66.74378, 112.7127 +10787, 69.8469, 150.5891 +10788, 69.66479, 144.4128 +10789, 70.61706, 122.7131 +10790, 64.87192, 127.745 +10791, 68.09578, 123.5007 +10792, 64.12978, 125.8286 +10793, 69.1366, 152.2569 +10794, 70.70527, 133.3353 +10795, 66.38376, 115.6821 +10796, 66.95437, 128.1657 +10797, 69.3349, 131.2696 +10798, 67.6326, 123.7498 +10799, 68.67163, 112.0543 +10800, 66.97528, 133.7971 +10801, 69.32415, 118.631 +10802, 68.65077, 117.349 +10803, 69.52713, 130.0545 +10804, 67.5071, 120.5993 +10805, 68.41559, 130.557 +10806, 67.18894, 119.2439 +10807, 67.64362, 129.8738 +10808, 67.63143, 111.9499 +10809, 71.0885, 144.0961 +10810, 66.35595, 135.0814 +10811, 66.55633, 125.1865 +10812, 69.48096, 144.4402 +10813, 72.13324, 141.1153 +10814, 68.37214, 130.76 +10815, 65.24215, 107.3398 +10816, 68.35973, 122.4447 +10817, 67.12836, 123.7953 +10818, 70.71221, 129.5686 +10819, 70.10355, 147.6963 +10820, 69.91417, 128.8815 +10821, 67.03445, 118.5148 +10822, 68.48906, 135.0043 +10823, 62.50449, 126.834 +10824, 66.28271, 122.121 +10825, 71.18243, 147.7423 +10826, 64.96701, 118.9745 +10827, 66.83755, 119.1425 +10828, 69.31263, 143.318 +10829, 68.00003, 124.0098 +10830, 70.93041, 138.5522 +10831, 69.55078, 127.6665 +10832, 67.04168, 125.6018 +10833, 66.68499, 126.4684 +10834, 66.96568, 144.4394 +10835, 66.45649, 106.8881 +10836, 69.38291, 114.7144 +10837, 68.39972, 131.8536 +10838, 65.99324, 118.3222 +10839, 68.32092, 136.5044 +10840, 69.10337, 130.0111 +10841, 68.42546, 121.4558 +10842, 68.20753, 133.0912 +10843, 67.8287, 126.2769 +10844, 66.20781, 123.2416 +10845, 70.02744, 132.5108 +10846, 72.33837, 146.1178 +10847, 69.07669, 133.8041 +10848, 63.47989, 109.4272 +10849, 68.39232, 132.9664 +10850, 66.38785, 107.8609 +10851, 66.35839, 141.0786 +10852, 67.90974, 127.899 +10853, 67.99457, 135.2005 +10854, 69.33638, 116.2041 +10855, 67.60547, 134.3536 +10856, 67.39241, 118.188 +10857, 65.40662, 138.0298 +10858, 67.08266, 125.0373 +10859, 66.1459, 117.1214 +10860, 69.02208, 147.0445 +10861, 65.41424, 118.1839 +10862, 62.44899, 97.60294 +10863, 66.46524, 116.9524 +10864, 70.5789, 125.9388 +10865, 67.11866, 129.8029 +10866, 69.02602, 117.0323 +10867, 65.29178, 103.3172 +10868, 67.25249, 122.7412 +10869, 67.7796, 135.983 +10870, 70.45204, 127.5806 +10871, 71.466, 136.1768 +10872, 67.65154, 114.2668 +10873, 67.83536, 133.7095 +10874, 67.38724, 124.5322 +10875, 67.91087, 122.5197 +10876, 65.85116, 119.9984 +10877, 70.53984, 145.7572 +10878, 65.54683, 127.3529 +10879, 66.72193, 124.4206 +10880, 68.08321, 142.2061 +10881, 69.15879, 133.4787 +10882, 66.47756, 121.2549 +10883, 64.37265, 111.2446 +10884, 72.18026, 145.5891 +10885, 69.04682, 141.238 +10886, 66.6879, 132.1882 +10887, 67.05403, 116.8532 +10888, 66.72188, 114.0862 +10889, 67.90779, 121.8853 +10890, 70.29567, 135.9697 +10891, 70.14594, 155.0147 +10892, 64.90698, 106.2489 +10893, 68.15533, 155.6542 +10894, 69.76311, 132.7484 +10895, 65.19432, 125.919 +10896, 68.60431, 130.8794 +10897, 68.31467, 139.5657 +10898, 69.28143, 124.0809 +10899, 66.72096, 120.1462 +10900, 66.2546, 136.0814 +10901, 70.41851, 126.6505 +10902, 69.15107, 122.1065 +10903, 65.90954, 119.7513 +10904, 68.92271, 123.6162 +10905, 68.88487, 130.892 +10906, 64.58076, 150.6921 +10907, 66.58124, 120.6348 +10908, 65.38313, 115.8133 +10909, 68.45964, 104.5201 +10910, 68.08292, 106.1436 +10911, 67.98588, 124.5469 +10912, 65.43668, 96.64915 +10913, 68.35283, 145.9472 +10914, 69.59921, 141.6018 +10915, 67.76728, 122.9415 +10916, 66.54611, 128.5828 +10917, 67.40557, 129.7861 +10918, 71.61858, 150.7782 +10919, 69.78806, 140.5096 +10920, 65.46436, 108.0159 +10921, 69.84842, 146.8392 +10922, 67.59114, 126.3141 +10923, 65.39097, 130.7129 +10924, 69.16565, 114.3258 +10925, 70.8537, 139.41 +10926, 69.64932, 137.3018 +10927, 69.75493, 121.4986 +10928, 67.29615, 126.7282 +10929, 68.00311, 103.2192 +10930, 68.23844, 123.0584 +10931, 69.10888, 139.3881 +10932, 69.16784, 132.2421 +10933, 67.40236, 107.6678 +10934, 66.97412, 115.914 +10935, 68.14213, 149.2678 +10936, 65.77882, 111.7485 +10937, 68.86055, 123.2045 +10938, 68.54418, 125.2815 +10939, 66.24232, 123.1627 +10940, 66.05281, 116.5253 +10941, 66.78253, 124.9536 +10942, 68.22373, 105.4156 +10943, 70.81098, 149.8862 +10944, 67.51193, 126.031 +10945, 68.7292, 144.2782 +10946, 69.03442, 137.2801 +10947, 66.69993, 127.0516 +10948, 67.66684, 137.4976 +10949, 70.04342, 156.4566 +10950, 70.71417, 128.557 +10951, 67.21338, 129.1064 +10952, 69.51067, 139.2973 +10953, 64.84702, 99.24033 +10954, 72.42524, 134.8079 +10955, 69.204, 117.0954 +10956, 70.63329, 144.9647 +10957, 70.21055, 122.4646 +10958, 70.91114, 134.6232 +10959, 67.6791, 111.4813 +10960, 68.51935, 127.5446 +10961, 67.49054, 125.2224 +10962, 70.94239, 127.097 +10963, 68.22454, 140.903 +10964, 67.8618, 122.2685 +10965, 65.79765, 104.3895 +10966, 66.93034, 119.7403 +10967, 65.2842, 114.2336 +10968, 69.92925, 124.9368 +10969, 71.99579, 120.0237 +10970, 67.26327, 114.2686 +10971, 65.66178, 113.5902 +10972, 66.50243, 131.9956 +10973, 67.66008, 144.2397 +10974, 71.24889, 136.9907 +10975, 64.63061, 121.5164 +10976, 69.61857, 133.2628 +10977, 64.98777, 136.4346 +10978, 70.80755, 132.1319 +10979, 67.21426, 105.3348 +10980, 69.62967, 124.178 +10981, 69.67729, 138.7077 +10982, 66.84127, 121.048 +10983, 67.95575, 138.3578 +10984, 67.91859, 103.1035 +10985, 68.29201, 110.3958 +10986, 70.71797, 131.3595 +10987, 68.38443, 143.1785 +10988, 66.02316, 113.8072 +10989, 66.51135, 110.2655 +10990, 68.05802, 110.1398 +10991, 68.09044, 126.9757 +10992, 67.63946, 114.1426 +10993, 68.35095, 126.1809 +10994, 66.916, 111.5822 +10995, 68.87816, 120.9969 +10996, 68.03941, 137.2248 +10997, 71.01294, 131.4479 +10998, 70.58233, 140.0745 +10999, 63.17217, 127.2456 +11000, 69.78974, 145.0778 +11001, 65.67569, 123.1591 +11002, 66.51317, 126.2002 +11003, 68.91807, 132.491 +11004, 67.54731, 105.6248 +11005, 67.16725, 117.6846 +11006, 70.30407, 138.4226 +11007, 67.94455, 118.7549 +11008, 70.17937, 134.815 +11009, 68.84277, 123.0811 +11010, 68.97817, 138.3514 +11011, 67.87172, 144.6941 +11012, 68.30452, 122.0263 +11013, 71.59581, 147.0324 +11014, 70.97786, 149.5895 +11015, 67.04114, 121.5026 +11016, 69.75259, 140.9001 +11017, 69.34609, 145.7199 +11018, 68.47204, 131.8399 +11019, 66.46867, 126.7618 +11020, 71.68515, 121.8591 +11021, 67.58847, 118.7126 +11022, 64.62583, 111.3351 +11023, 68.08467, 120.0023 +11024, 69.04082, 110.3399 +11025, 71.47469, 140.2681 +11026, 68.29856, 127.8518 +11027, 66.48835, 118.2103 +11028, 67.65551, 118.4708 +11029, 69.55965, 130.298 +11030, 68.07654, 109.852 +11031, 69.53635, 116.8769 +11032, 66.55122, 116.5006 +11033, 71.81797, 139.7074 +11034, 69.15297, 126.3293 +11035, 67.38721, 135.5659 +11036, 64.94889, 113.0076 +11037, 68.1155, 136.263 +11038, 67.87942, 118.7067 +11039, 71.15678, 153.5749 +11040, 69.55755, 119.7754 +11041, 67.32935, 133.2197 +11042, 67.03618, 121.7936 +11043, 67.08475, 132.8759 +11044, 68.1142, 123.9844 +11045, 67.25607, 124.3161 +11046, 68.93456, 134.6034 +11047, 70.99654, 137.4312 +11048, 66.66773, 130.2486 +11049, 67.14848, 124.8785 +11050, 68.01276, 119.6507 +11051, 68.37466, 113.7195 +11052, 67.63132, 127.4093 +11053, 68.78129, 130.9664 +11054, 67.4519, 109.2884 +11055, 69.05692, 129.9515 +11056, 71.58656, 151.926 +11057, 71.00215, 133.315 +11058, 65.48034, 115.4925 +11059, 64.84197, 106.4034 +11060, 67.77064, 142.9326 +11061, 68.789, 120.5641 +11062, 67.73549, 122.7611 +11063, 67.28621, 133.0996 +11064, 69.14033, 131.7311 +11065, 63.68432, 113.8885 +11066, 66.48606, 123.3001 +11067, 66.82771, 133.2493 +11068, 65.74972, 106.1128 +11069, 70.15496, 132.2557 +11070, 68.03163, 124.7543 +11071, 68.73994, 136.6091 +11072, 66.67274, 105.848 +11073, 70.44164, 143.7073 +11074, 65.21801, 107.4109 +11075, 69.18892, 110.2616 +11076, 65.7164, 123.6866 +11077, 68.20774, 124.8594 +11078, 65.6085, 122.0489 +11079, 66.99553, 105.2913 +11080, 70.96623, 131.4938 +11081, 64.28708, 99.82706 +11082, 63.60355, 122.3891 +11083, 65.05165, 118.8598 +11084, 67.83126, 121.3917 +11085, 65.8442, 122.9715 +11086, 68.81007, 136.9345 +11087, 69.08438, 127.0724 +11088, 67.94823, 120.2966 +11089, 69.52463, 129.9461 +11090, 67.97769, 144.7071 +11091, 64.96741, 109.2457 +11092, 65.55484, 129.2687 +11093, 68.0052, 117.0722 +11094, 68.62033, 139.7228 +11095, 69.17078, 131.3516 +11096, 68.50566, 124.308 +11097, 67.40238, 137.9187 +11098, 65.09312, 135.5254 +11099, 68.9391, 137.8963 +11100, 69.19971, 138.739 +11101, 68.16393, 131.1518 +11102, 69.91225, 150.7507 +11103, 66.13776, 112.7742 +11104, 65.84225, 135.3841 +11105, 66.51608, 132.3072 +11106, 65.39554, 129.0537 +11107, 68.35417, 135.2684 +11108, 65.85458, 146.8202 +11109, 66.08547, 126.153 +11110, 69.56261, 130.0292 +11111, 68.54207, 137.6653 +11112, 71.27061, 124.2243 +11113, 66.03755, 129.0106 +11114, 68.42545, 124.8365 +11115, 69.56302, 130.9521 +11116, 69.77139, 143.4356 +11117, 70.26466, 123.3935 +11118, 70.02833, 133.9895 +11119, 69.23495, 131.8937 +11120, 67.75034, 118.8212 +11121, 65.59472, 110.1066 +11122, 69.77645, 149.6136 +11123, 69.46001, 145.2864 +11124, 68.43554, 135.4124 +11125, 67.05033, 114.3176 +11126, 66.57575, 127.931 +11127, 66.15214, 128.4151 +11128, 69.05944, 136.7033 +11129, 66.27918, 138.907 +11130, 67.25881, 135.2798 +11131, 67.83695, 127.7505 +11132, 65.96984, 130.823 +11133, 64.81822, 116.6434 +11134, 68.43412, 145.7155 +11135, 67.49384, 113.4681 +11136, 69.01647, 137.0928 +11137, 68.57292, 117.2929 +11138, 67.87708, 123.0777 +11139, 68.99385, 131.2152 +11140, 66.69195, 108.4437 +11141, 65.30731, 118.1043 +11142, 67.63371, 127.8296 +11143, 67.76547, 127.0117 +11144, 69.46199, 124.0249 +11145, 69.137, 123.3187 +11146, 70.76924, 140.8299 +11147, 69.74567, 113.057 +11148, 70.86609, 144.0689 +11149, 67.96674, 148.2726 +11150, 68.52434, 120.6406 +11151, 70.47887, 133.3292 +11152, 68.13987, 133.8585 +11153, 67.62197, 96.74634 +11154, 67.40406, 134.0505 +11155, 70.70493, 144.4624 +11156, 67.0114, 119.1376 +11157, 70.72181, 125.5266 +11158, 65.0906, 113.8999 +11159, 71.66102, 140.5407 +11160, 69.64489, 119.1443 +11161, 66.06372, 140.0926 +11162, 69.53887, 133.4508 +11163, 66.72469, 130.7197 +11164, 69.14268, 161.3014 +11165, 68.47042, 122.3227 +11166, 68.56545, 125.885 +11167, 70.33392, 140.3581 +11168, 64.83586, 128.4784 +11169, 67.00076, 133.8422 +11170, 67.61172, 132.1716 +11171, 69.2627, 122.9415 +11172, 68.05574, 125.929 +11173, 67.01389, 114.5908 +11174, 74.16797, 142.7732 +11175, 67.46023, 123.9729 +11176, 66.59883, 140.0618 +11177, 65.20591, 114.1975 +11178, 69.12252, 143.4608 +11179, 69.04489, 125.9477 +11180, 67.23588, 134.934 +11181, 66.53866, 124.4463 +11182, 69.2864, 139.5923 +11183, 67.22009, 133.8821 +11184, 68.40132, 109.7327 +11185, 68.52054, 130.0861 +11186, 66.77642, 148.078 +11187, 70.20339, 137.6673 +11188, 67.77726, 138.0438 +11189, 65.15073, 99.8475 +11190, 68.77137, 129.1743 +11191, 70.98235, 127.8665 +11192, 67.44011, 138.8552 +11193, 67.5907, 137.1565 +11194, 68.09234, 122.353 +11195, 68.58477, 119.8123 +11196, 63.92414, 94.96925 +11197, 67.13792, 126.5541 +11198, 67.96822, 131.4434 +11199, 67.40732, 117.0252 +11200, 70.08201, 142.9877 +11201, 67.77124, 119.2235 +11202, 69.15034, 127.5277 +11203, 67.00199, 137.932 +11204, 69.23248, 132.5571 +11205, 67.98002, 129.1731 +11206, 67.20279, 102.0226 +11207, 68.98976, 124.2182 +11208, 68.5983, 126.5379 +11209, 66.25204, 146.6106 +11210, 63.77589, 127.3544 +11211, 67.96185, 125.154 +11212, 66.16809, 111.7997 +11213, 68.50417, 131.5771 +11214, 67.70934, 136.3176 +11215, 63.33119, 112.6251 +11216, 70.0918, 139.5179 +11217, 68.30094, 134.7177 +11218, 66.46884, 138.402 +11219, 68.88676, 127.648 +11220, 69.38352, 122.0678 +11221, 69.00483, 137.6559 +11222, 70.05784, 116.6165 +11223, 65.10116, 123.1258 +11224, 71.15266, 130.5181 +11225, 67.87661, 108.9897 +11226, 66.02093, 127.3182 +11227, 67.78396, 114.3916 +11228, 69.83424, 118.4764 +11229, 66.39018, 108.4403 +11230, 67.72204, 116.2668 +11231, 67.0671, 110.0552 +11232, 70.70367, 135.5553 +11233, 70.03981, 138.4753 +11234, 68.47663, 138.7668 +11235, 69.2047, 140.5522 +11236, 65.23394, 112.5476 +11237, 68.89622, 144.4723 +11238, 71.20184, 146.1089 +11239, 73.45384, 142.0065 +11240, 64.68783, 129.2138 +11241, 66.5181, 97.54695 +11242, 66.56509, 111.3128 +11243, 67.75376, 105.9587 +11244, 62.91681, 123.054 +11245, 65.18677, 111.6079 +11246, 66.5578, 116.3412 +11247, 71.6577, 143.3796 +11248, 64.46785, 118.9773 +11249, 66.28272, 112.249 +11250, 68.42883, 119.7445 +11251, 69.38397, 123.9979 +11252, 65.31926, 120.0737 +11253, 68.66193, 123.2477 +11254, 65.97339, 115.6794 +11255, 69.51667, 129.7024 +11256, 68.22985, 122.1816 +11257, 69.83, 136.8307 +11258, 63.61518, 107.139 +11259, 67.99998, 136.646 +11260, 66.89939, 144.4917 +11261, 68.73884, 133.8346 +11262, 69.17398, 139.6385 +11263, 70.58871, 131.6732 +11264, 67.8682, 119.9805 +11265, 68.39892, 134.7468 +11266, 67.88895, 121.1382 +11267, 64.38742, 116.0245 +11268, 66.96466, 129.3706 +11269, 65.86538, 128.5607 +11270, 65.82647, 122.1977 +11271, 70.51289, 138.8583 +11272, 70.42931, 125.3635 +11273, 66.10171, 118.9452 +11274, 65.46048, 131.205 +11275, 70.91162, 140.5079 +11276, 68.69449, 127.6927 +11277, 71.75246, 149.9238 +11278, 64.82819, 143.4204 +11279, 66.6091, 109.1462 +11280, 67.779, 133.1513 +11281, 66.56978, 128.282 +11282, 68.13511, 115.708 +11283, 68.51757, 119.3005 +11284, 68.07689, 121.7782 +11285, 70.14804, 133.7709 +11286, 70.35962, 144.1309 +11287, 67.58689, 118.6697 +11288, 65.03137, 125.7451 +11289, 67.36342, 127.2779 +11290, 65.76034, 109.628 +11291, 67.10885, 122.7538 +11292, 68.75557, 143.1601 +11293, 70.97344, 129.3743 +11294, 65.26892, 127.3683 +11295, 65.66247, 131.7569 +11296, 66.53827, 113.4029 +11297, 66.90975, 128.4934 +11298, 69.51623, 131.5506 +11299, 66.61461, 114.4853 +11300, 71.62343, 119.7512 +11301, 70.05513, 123.5191 +11302, 67.48898, 125.501 +11303, 68.36694, 104.503 +11304, 69.26121, 129.5221 +11305, 67.87778, 130.2365 +11306, 63.20626, 116.3739 +11307, 69.67947, 134.5489 +11308, 67.37164, 124.1367 +11309, 67.66896, 114.7549 +11310, 67.71607, 111.9589 +11311, 67.58095, 136.4722 +11312, 68.11599, 117.5179 +11313, 68.93673, 144.2782 +11314, 67.62937, 120.1249 +11315, 65.94814, 121.1693 +11316, 69.25978, 134.5615 +11317, 65.95706, 128.8891 +11318, 67.99681, 130.7289 +11319, 67.76218, 137.1791 +11320, 66.67503, 122.4975 +11321, 66.98501, 125.9014 +11322, 67.45441, 131.5585 +11323, 66.42304, 127.2729 +11324, 67.08303, 128.7227 +11325, 66.55348, 110.5548 +11326, 66.76286, 139.0637 +11327, 68.62482, 147.0216 +11328, 67.54028, 126.4595 +11329, 68.83293, 131.422 +11330, 67.36371, 116.3804 +11331, 68.47048, 133.9893 +11332, 67.35037, 132.3045 +11333, 68.10823, 125.0725 +11334, 68.51138, 131.3701 +11335, 68.68777, 114.4842 +11336, 66.79129, 121.9002 +11337, 67.79664, 115.3191 +11338, 68.8252, 137.6658 +11339, 66.59959, 127.6122 +11340, 65.16559, 121.0852 +11341, 68.93245, 127.1722 +11342, 69.16312, 132.6592 +11343, 69.49148, 121.6419 +11344, 66.46241, 132.0125 +11345, 69.93643, 141.8868 +11346, 68.58906, 118.2895 +11347, 65.72053, 127.1461 +11348, 67.94094, 104.2896 +11349, 68.11806, 131.5896 +11350, 69.43335, 140.3956 +11351, 68.95852, 130.0709 +11352, 68.00487, 92.95851 +11353, 65.62079, 100.0969 +11354, 69.52389, 118.3399 +11355, 64.75006, 108.3967 +11356, 70.17871, 121.1313 +11357, 68.68662, 148.4892 +11358, 65.90203, 109.0414 +11359, 67.41875, 122.7271 +11360, 68.51834, 125.1308 +11361, 70.02573, 158.5864 +11362, 68.74884, 129.8334 +11363, 69.46722, 120.5883 +11364, 67.36649, 125.7361 +11365, 68.23045, 140.7733 +11366, 67.9815, 125.7448 +11367, 68.72434, 123.4432 +11368, 71.81276, 136.7116 +11369, 63.63521, 101.8813 +11370, 67.11628, 139.6614 +11371, 67.51086, 114.2835 +11372, 69.88008, 124.5219 +11373, 66.37702, 105.9248 +11374, 67.77136, 126.5531 +11375, 67.01918, 131.7105 +11376, 66.55379, 126.9896 +11377, 66.72728, 111.0062 +11378, 69.10831, 139.2123 +11379, 70.36453, 128.2677 +11380, 66.25151, 131.1318 +11381, 67.61697, 107.4615 +11382, 67.69783, 120.3788 +11383, 66.46549, 117.7681 +11384, 67.59571, 130.1581 +11385, 70.4309, 134.4154 +11386, 65.11059, 97.59535 +11387, 67.47219, 135.7524 +11388, 66.65897, 113.2162 +11389, 64.2838, 126.9371 +11390, 68.47012, 127.5937 +11391, 66.25226, 117.278 +11392, 68.30287, 137.5881 +11393, 70.01965, 130.8984 +11394, 66.94063, 132.4786 +11395, 65.36655, 132.6127 +11396, 66.4126, 114.6091 +11397, 68.26581, 125.0861 +11398, 68.2852, 118.9217 +11399, 67.42465, 141.9674 +11400, 63.37186, 115.6628 +11401, 69.72835, 123.179 +11402, 66.38974, 94.80076 +11403, 69.55925, 131.0935 +11404, 69.54116, 117.8275 +11405, 67.83505, 121.0242 +11406, 68.22833, 143.0423 +11407, 68.45736, 132.6294 +11408, 67.01063, 120.9344 +11409, 67.58458, 147.5025 +11410, 67.11171, 111.7266 +11411, 66.05492, 120.0749 +11412, 65.65432, 121.643 +11413, 67.09664, 148.0281 +11414, 68.93253, 109.7752 +11415, 67.50893, 112.6096 +11416, 67.88135, 142.5829 +11417, 70.51084, 130.5145 +11418, 68.07978, 140.6775 +11419, 69.61803, 131.27 +11420, 65.53941, 121.7807 +11421, 66.70491, 134.6241 +11422, 68.82601, 115.8979 +11423, 70.60592, 135.8761 +11424, 67.08397, 124.4171 +11425, 67.58198, 138.0321 +11426, 67.32686, 105.214 +11427, 67.85523, 132.0323 +11428, 66.15898, 146.9268 +11429, 67.95819, 124.9584 +11430, 65.16544, 129.9676 +11431, 69.54452, 146.005 +11432, 66.35121, 121.1278 +11433, 68.26571, 136.2651 +11434, 70.29475, 130.4589 +11435, 68.02599, 142.3053 +11436, 65.53207, 118.0806 +11437, 70.76347, 150.6201 +11438, 65.3266, 123.7902 +11439, 66.51846, 130.4262 +11440, 66.29182, 129.1751 +11441, 66.16228, 125.6023 +11442, 67.97724, 134.5728 +11443, 66.47067, 105.241 +11444, 67.51785, 136.9115 +11445, 69.16624, 135.3094 +11446, 70.0874, 131.5153 +11447, 68.02869, 123.587 +11448, 67.82592, 133.6891 +11449, 67.61981, 104.6315 +11450, 65.9637, 130.3269 +11451, 67.72006, 103.2679 +11452, 67.48496, 91.91782 +11453, 68.24513, 128.9407 +11454, 67.35061, 135.0216 +11455, 68.18075, 135.0446 +11456, 70.672, 124.9177 +11457, 66.81834, 126.3595 +11458, 68.75229, 126.7573 +11459, 67.35564, 126.2663 +11460, 66.95961, 129.0322 +11461, 67.73721, 111.3459 +11462, 67.64532, 140.2121 +11463, 65.21358, 124.1369 +11464, 65.1571, 131.4201 +11465, 67.40133, 122.2223 +11466, 67.65074, 137.8933 +11467, 63.8874, 114.223 +11468, 66.85228, 124.4828 +11469, 65.93881, 125.8178 +11470, 65.07901, 121.0964 +11471, 68.66259, 138.6358 +11472, 66.63069, 144.0267 +11473, 68.1916, 121.9667 +11474, 64.72033, 119.4164 +11475, 67.76005, 129.9217 +11476, 67.78329, 126.7556 +11477, 68.09923, 126.4184 +11478, 69.21335, 128.8556 +11479, 67.75819, 137.4614 +11480, 70.39946, 134.2599 +11481, 65.93766, 127.9704 +11482, 66.11839, 127.0232 +11483, 66.01019, 115.0187 +11484, 71.63081, 135.4107 +11485, 66.62993, 144.5351 +11486, 68.48521, 90.53995 +11487, 68.10699, 129.2909 +11488, 70.27703, 134.3019 +11489, 69.75105, 126.0679 +11490, 68.98237, 115.8649 +11491, 65.64452, 125.3238 +11492, 68.91636, 124.459 +11493, 66.61896, 132.9899 +11494, 68.60604, 125.6796 +11495, 67.30725, 123.1893 +11496, 70.75095, 135.5127 +11497, 67.58887, 124.922 +11498, 64.50132, 123.3747 +11499, 73.27528, 142.7375 +11500, 68.25937, 129.5475 +11501, 67.91946, 118.9415 +11502, 67.31071, 112.7087 +11503, 67.7966, 137.8801 +11504, 71.29452, 144.6277 +11505, 68.27275, 115.1205 +11506, 66.86544, 104.0809 +11507, 67.73325, 106.3248 +11508, 70.2269, 146.4763 +11509, 69.62197, 133.916 +11510, 67.48527, 109.9157 +11511, 68.09415, 131.2306 +11512, 66.09287, 147.1966 +11513, 67.42801, 128.0001 +11514, 69.08861, 111.019 +11515, 65.70473, 119.4562 +11516, 66.52344, 134.9003 +11517, 68.67632, 115.3375 +11518, 68.36099, 131.3844 +11519, 66.34405, 114.0256 +11520, 65.46233, 101.7174 +11521, 65.38562, 92.82921 +11522, 70.29342, 131.0869 +11523, 66.81702, 107.4364 +11524, 67.09018, 126.1098 +11525, 69.10457, 137.515 +11526, 68.6582, 126.1272 +11527, 67.69463, 129.6272 +11528, 69.41766, 135.0258 +11529, 64.90194, 123.585 +11530, 66.4883, 136.8641 +11531, 71.09216, 123.2561 +11532, 71.94657, 134.3756 +11533, 68.15531, 137.0752 +11534, 68.32479, 124.3728 +11535, 70.93105, 119.3693 +11536, 62.55787, 105.7505 +11537, 68.72459, 133.1973 +11538, 68.56969, 123.2818 +11539, 70.70114, 129.2904 +11540, 67.2195, 134.9439 +11541, 69.42099, 145.046 +11542, 65.2954, 122.5997 +11543, 67.5127, 127.4652 +11544, 68.61443, 130.1691 +11545, 68.23227, 129.3011 +11546, 69.06606, 124.9616 +11547, 67.76769, 132.9052 +11548, 67.19954, 131.7003 +11549, 66.19999, 111.3766 +11550, 67.15817, 124.6763 +11551, 65.80976, 119.5688 +11552, 68.72661, 148.7831 +11553, 71.01527, 115.5961 +11554, 70.3378, 122.886 +11555, 66.60132, 117.6958 +11556, 66.10835, 118.365 +11557, 65.54454, 125.6417 +11558, 67.08775, 139.4027 +11559, 70.91229, 151.9319 +11560, 70.05033, 135.0001 +11561, 67.91474, 130.4542 +11562, 70.44997, 140.0553 +11563, 69.43277, 112.1645 +11564, 70.69946, 131.2794 +11565, 69.62487, 120.4721 +11566, 70.95555, 134.9733 +11567, 69.55239, 154.2355 +11568, 66.67652, 116.072 +11569, 68.94487, 136.0275 +11570, 69.06771, 126.5166 +11571, 68.68065, 113.9339 +11572, 69.75765, 118.3588 +11573, 65.74407, 112.5993 +11574, 69.90579, 118.7813 +11575, 67.49642, 144.7324 +11576, 71.55734, 146.4177 +11577, 68.87168, 132.5791 +11578, 67.23421, 117.092 +11579, 68.63376, 119.0942 +11580, 68.65065, 118.3285 +11581, 66.63756, 135.3268 +11582, 67.87931, 113.0279 +11583, 65.95049, 144.2777 +11584, 69.46751, 118.2912 +11585, 65.32821, 107.3803 +11586, 66.76294, 121.2519 +11587, 68.5428, 117.004 +11588, 68.91044, 142.8254 +11589, 68.84368, 150.6553 +11590, 73.38937, 136.7121 +11591, 66.86841, 116.4109 +11592, 67.52516, 107.2826 +11593, 68.13449, 121.8903 +11594, 68.39998, 129.8416 +11595, 68.75545, 141.6232 +11596, 71.22681, 118.0369 +11597, 69.02697, 118.4175 +11598, 69.36506, 149.4627 +11599, 71.48858, 139.2446 +11600, 70.03975, 139.38 +11601, 65.86983, 115.7434 +11602, 64.18612, 112.8632 +11603, 68.22537, 119.4641 +11604, 67.57609, 126.8161 +11605, 68.32838, 125.0752 +11606, 69.7812, 146.0231 +11607, 64.60544, 98.10936 +11608, 69.35659, 137.7401 +11609, 65.08819, 129.1596 +11610, 67.25428, 125.3354 +11611, 67.29744, 111.402 +11612, 69.06367, 128.8616 +11613, 70.66513, 132.245 +11614, 66.34245, 136.4106 +11615, 66.88466, 133.7811 +11616, 69.83988, 132.9299 +11617, 68.64288, 108.615 +11618, 68.78708, 142.8921 +11619, 68.36723, 127.2684 +11620, 71.12176, 119.0967 +11621, 68.55132, 118.0137 +11622, 71.18105, 147.7838 +11623, 68.32621, 125.1014 +11624, 66.83958, 117.8889 +11625, 69.20216, 144.7944 +11626, 66.77853, 128.7692 +11627, 66.4406, 118.4163 +11628, 69.02771, 136.656 +11629, 65.99368, 145.7856 +11630, 68.21133, 126.3564 +11631, 68.81559, 105.3418 +11632, 69.54378, 136.0772 +11633, 67.04297, 120.8592 +11634, 69.61676, 121.0389 +11635, 69.11044, 136.6009 +11636, 64.55954, 123.4204 +11637, 65.79362, 132.5145 +11638, 68.99934, 125.0189 +11639, 66.16092, 137.0073 +11640, 64.3685, 110.0215 +11641, 69.87282, 124.8993 +11642, 66.0047, 116.8211 +11643, 68.96687, 121.3857 +11644, 67.76358, 142.8913 +11645, 67.2019, 118.5255 +11646, 67.67049, 138.3916 +11647, 65.94121, 121.8284 +11648, 62.62398, 113.6392 +11649, 68.6687, 148.4025 +11650, 64.99303, 134.3959 +11651, 70.14061, 133.8105 +11652, 67.33278, 111.0307 +11653, 71.15018, 127.3908 +11654, 68.05094, 123.1092 +11655, 70.68057, 122.0871 +11656, 66.92683, 132.5142 +11657, 67.32022, 121.7055 +11658, 65.96371, 126.1179 +11659, 66.36048, 131.4652 +11660, 70.09062, 141.6373 +11661, 66.77067, 114.939 +11662, 68.7819, 128.8125 +11663, 68.06198, 125.1513 +11664, 66.87471, 124.1839 +11665, 64.991, 120.5915 +11666, 64.24525, 119.3337 +11667, 64.62759, 117.0906 +11668, 67.47845, 125.0172 +11669, 68.38035, 120.3051 +11670, 67.9413, 140.2045 +11671, 69.38765, 120.404 +11672, 69.72585, 141.0221 +11673, 64.85369, 140.5568 +11674, 71.14569, 144.9609 +11675, 67.93166, 116.703 +11676, 65.8737, 130.7339 +11677, 65.27492, 120.7876 +11678, 64.36283, 122.0425 +11679, 66.53787, 116.5946 +11680, 69.52399, 133.0562 +11681, 69.13837, 139.6702 +11682, 67.67203, 123.8558 +11683, 68.95441, 141.2783 +11684, 71.04477, 140.3705 +11685, 71.39529, 149.7633 +11686, 66.54494, 127.3852 +11687, 68.28091, 136.24 +11688, 67.50144, 139.3232 +11689, 68.29474, 133.1216 +11690, 70.15135, 125.669 +11691, 69.41645, 135.8714 +11692, 69.36098, 123.6386 +11693, 67.16252, 130.6726 +11694, 68.53052, 125.4746 +11695, 69.64804, 116.6893 +11696, 66.68536, 116.2552 +11697, 65.89405, 114.064 +11698, 67.96456, 118.3278 +11699, 64.66704, 113.2242 +11700, 67.83132, 131.1598 +11701, 69.37264, 132.3018 +11702, 64.63475, 122.2873 +11703, 68.45736, 121.5602 +11704, 63.66412, 121.3552 +11705, 68.23574, 134.2459 +11706, 69.90933, 145.0568 +11707, 66.34353, 119.2517 +11708, 71.08621, 131.099 +11709, 69.29874, 113.3891 +11710, 69.26027, 136.8925 +11711, 68.3563, 136.5469 +11712, 68.82059, 134.8073 +11713, 67.11847, 123.4971 +11714, 70.16349, 136.7408 +11715, 67.31192, 139.7817 +11716, 65.99526, 117.9879 +11717, 70.32862, 133.2887 +11718, 66.35638, 130.9393 +11719, 65.46699, 113.0275 +11720, 67.06126, 114.7648 +11721, 69.37876, 133.7697 +11722, 68.55299, 132.1181 +11723, 64.28602, 117.6389 +11724, 66.98559, 124.8642 +11725, 68.3511, 129.34 +11726, 70.92088, 138.3304 +11727, 65.62372, 122.5121 +11728, 67.60294, 131.5862 +11729, 65.45098, 109.587 +11730, 65.9003, 124.6232 +11731, 69.28348, 142.1931 +11732, 69.00879, 142.8201 +11733, 69.72132, 127.0407 +11734, 68.26773, 136.2919 +11735, 65.26077, 107.3359 +11736, 66.6262, 136.8962 +11737, 68.5705, 121.4571 +11738, 71.51468, 139.7799 +11739, 67.97982, 121.0927 +11740, 68.26653, 134.6471 +11741, 66.37001, 133.1274 +11742, 65.56004, 114.0317 +11743, 68.20536, 128.2957 +11744, 70.14549, 138.6955 +11745, 66.01422, 114.0106 +11746, 65.59692, 127.598 +11747, 66.31345, 109.8002 +11748, 70.52695, 151.5058 +11749, 65.76106, 113.6272 +11750, 69.682, 135.5456 +11751, 68.90157, 141.6732 +11752, 63.87521, 128.004 +11753, 69.44937, 144.3768 +11754, 70.3846, 166.7687 +11755, 69.16422, 138.4332 +11756, 71.0881, 151.926 +11757, 64.77026, 106.4436 +11758, 69.03944, 115.6827 +11759, 68.3332, 121.3881 +11760, 67.65971, 131.6348 +11761, 65.95743, 129.7027 +11762, 68.25092, 114.8441 +11763, 70.46955, 127.5134 +11764, 69.87183, 154.5964 +11765, 70.761, 128.8214 +11766, 67.36771, 123.046 +11767, 68.31548, 114.5312 +11768, 65.10293, 133.1303 +11769, 65.23562, 107.844 +11770, 70.83969, 136.9762 +11771, 68.39903, 129.656 +11772, 68.20073, 118.2019 +11773, 66.94098, 139.2128 +11774, 66.07977, 131.8414 +11775, 63.36659, 123.006 +11776, 68.65857, 126.6649 +11777, 67.37221, 137.1801 +11778, 68.43509, 136.8554 +11779, 66.22392, 122.5205 +11780, 71.65466, 141.219 +11781, 66.69573, 125.1122 +11782, 66.8559, 122.1614 +11783, 68.02755, 134.7933 +11784, 67.70778, 122.2427 +11785, 63.85135, 120.1494 +11786, 69.93291, 133.902 +11787, 65.84544, 129.7101 +11788, 66.74059, 135.5989 +11789, 66.49611, 132.8285 +11790, 68.53937, 136.0357 +11791, 68.24023, 126.5821 +11792, 70.03063, 139.0857 +11793, 67.70792, 122.902 +11794, 67.72492, 117.4035 +11795, 68.84977, 133.9518 +11796, 68.71268, 126.3643 +11797, 68.0793, 130.2869 +11798, 68.30545, 131.6604 +11799, 70.86867, 126.5751 +11800, 68.31463, 113.4925 +11801, 67.62648, 110.1234 +11802, 71.14779, 142.3998 +11803, 67.34629, 107.1787 +11804, 66.62532, 120.6675 +11805, 66.68854, 122.4703 +11806, 69.90665, 159.966 +11807, 65.51279, 108.7832 +11808, 67.47262, 117.2175 +11809, 66.25672, 116.7766 +11810, 68.30086, 127.6778 +11811, 68.31294, 138.8446 +11812, 68.45399, 108.1145 +11813, 68.64421, 140.159 +11814, 65.31594, 106.6611 +11815, 68.32665, 139.0646 +11816, 69.77082, 136.0617 +11817, 66.20932, 133.0581 +11818, 68.43401, 119.8631 +11819, 65.25387, 116.2822 +11820, 71.7355, 162.0943 +11821, 67.76721, 148.8833 +11822, 70.51655, 141.3628 +11823, 70.4336, 136.7627 +11824, 64.25671, 114.8728 +11825, 69.37609, 128.0026 +11826, 71.07934, 134.5151 +11827, 71.70178, 124.1645 +11828, 67.3987, 111.3275 +11829, 63.62986, 113.608 +11830, 67.13345, 116.9574 +11831, 68.70886, 129.1443 +11832, 67.71809, 123.3103 +11833, 67.72767, 128.2164 +11834, 70.07335, 132.9222 +11835, 64.20874, 124.7975 +11836, 70.10636, 114.9911 +11837, 65.16199, 110.9849 +11838, 68.53018, 125.2053 +11839, 69.79457, 131.1487 +11840, 67.28489, 105.2101 +11841, 69.49036, 129.6225 +11842, 65.42646, 111.7143 +11843, 66.31501, 105.8468 +11844, 65.73484, 104.5094 +11845, 71.30941, 152.3587 +11846, 70.22624, 147.9016 +11847, 68.04495, 130.2388 +11848, 70.27278, 138.2409 +11849, 66.97106, 135.2028 +11850, 68.55277, 123.7852 +11851, 66.17403, 118.887 +11852, 71.37583, 143.3104 +11853, 68.1764, 130.5409 +11854, 66.28408, 142.1004 +11855, 68.15962, 113.7851 +11856, 70.00181, 137.8272 +11857, 65.30659, 129.8103 +11858, 65.67376, 120.5005 +11859, 68.92178, 119.6501 +11860, 67.6359, 140.8418 +11861, 67.91694, 119.803 +11862, 67.48812, 130.9508 +11863, 69.30675, 115.0445 +11864, 67.86395, 132.5698 +11865, 65.71274, 124.7391 +11866, 67.33136, 126.6475 +11867, 69.31735, 122.5178 +11868, 67.52153, 136.845 +11869, 67.79825, 120.662 +11870, 69.26416, 131.5304 +11871, 66.49667, 109.7068 +11872, 66.038, 110.9574 +11873, 68.29789, 116.7817 +11874, 69.05551, 130.8969 +11875, 65.0319, 133.1258 +11876, 69.31651, 138.9581 +11877, 66.21304, 128.8419 +11878, 66.18026, 122.4841 +11879, 68.86646, 120.4853 +11880, 67.86276, 148.8508 +11881, 67.17639, 121.491 +11882, 66.17, 112.3456 +11883, 69.25778, 118.8957 +11884, 72.80628, 150.9784 +11885, 67.49802, 145.0319 +11886, 68.53323, 106.9801 +11887, 67.72701, 110.8524 +11888, 67.403, 123.071 +11889, 70.97371, 137.9285 +11890, 65.88602, 127.0234 +11891, 64.69625, 116.2922 +11892, 65.07999, 107.0743 +11893, 67.33598, 107.7602 +11894, 67.17823, 120.969 +11895, 68.2152, 122.5298 +11896, 68.27877, 120.1926 +11897, 70.32072, 125.2459 +11898, 68.84149, 118.773 +11899, 65.41384, 127.5122 +11900, 66.90698, 122.5176 +11901, 66.92565, 109.6505 +11902, 72.16852, 125.865 +11903, 67.58419, 124.551 +11904, 71.05097, 139.1868 +11905, 68.65329, 121.3343 +11906, 71.13818, 125.2209 +11907, 69.83064, 113.8154 +11908, 69.24294, 128.4726 +11909, 70.80795, 148.2193 +11910, 71.4514, 142.4792 +11911, 68.34795, 137.6452 +11912, 66.96807, 123.2171 +11913, 67.35193, 135.7481 +11914, 66.3123, 119.4157 +11915, 68.38857, 153.2032 +11916, 68.72186, 120.7069 +11917, 64.6156, 124.8206 +11918, 71.04385, 149.3598 +11919, 65.5576, 112.7 +11920, 71.7762, 137.0197 +11921, 67.66805, 129.1137 +11922, 70.38662, 113.1486 +11923, 65.05914, 117.2483 +11924, 69.29376, 144.4311 +11925, 68.92487, 123.064 +11926, 73.23153, 140.2285 +11927, 67.98518, 122.4877 +11928, 66.02174, 106.7391 +11929, 62.50806, 121.7353 +11930, 67.11208, 124.9627 +11931, 67.2525, 131.7284 +11932, 66.86219, 107.2551 +11933, 66.11034, 111.458 +11934, 69.21797, 134.1583 +11935, 66.86285, 109.4149 +11936, 66.72363, 103.4764 +11937, 67.91114, 123.3007 +11938, 70.15546, 129.1033 +11939, 65.1448, 108.0862 +11940, 69.16116, 125.1179 +11941, 69.14544, 144.9626 +11942, 66.79109, 114.8214 +11943, 68.56128, 127.5046 +11944, 67.77908, 120.1861 +11945, 65.8903, 108.1277 +11946, 64.91798, 117.1005 +11947, 65.51983, 115.2811 +11948, 70.39488, 121.3756 +11949, 68.71595, 120.2871 +11950, 69.40879, 142.2191 +11951, 63.95804, 93.96913 +11952, 68.49986, 131.1487 +11953, 65.03967, 114.2779 +11954, 67.09578, 123.9914 +11955, 70.39063, 119.3835 +11956, 69.13445, 124.7073 +11957, 69.81349, 127.3314 +11958, 67.15358, 107.2308 +11959, 66.3247, 110.6354 +11960, 67.2547, 133.9845 +11961, 67.30359, 114.8441 +11962, 68.31411, 126.3453 +11963, 66.84937, 121.8716 +11964, 66.02415, 111.5549 +11965, 69.15659, 122.1897 +11966, 68.93022, 109.462 +11967, 66.03322, 102.562 +11968, 67.12476, 120.4642 +11969, 70.94314, 133.0277 +11970, 67.95293, 137.02 +11971, 68.2514, 152.4285 +11972, 69.5022, 126.022 +11973, 72.63806, 146.3356 +11974, 67.81132, 131.4317 +11975, 71.26903, 166.1956 +11976, 67.11464, 124.0268 +11977, 67.08781, 117.2354 +11978, 66.62197, 140.1115 +11979, 69.37986, 139.854 +11980, 65.72499, 112.01 +11981, 68.05531, 108.54 +11982, 71.06203, 142.837 +11983, 67.01009, 135.9007 +11984, 67.96128, 130.9758 +11985, 69.62918, 143.2022 +11986, 71.18686, 128.6857 +11987, 67.21088, 125.6535 +11988, 69.75744, 138.2061 +11989, 67.93962, 108.2722 +11990, 64.2564, 119.722 +11991, 70.57913, 130.738 +11992, 70.59481, 124.6141 +11993, 69.45839, 148.5158 +11994, 65.57668, 125.7709 +11995, 67.43466, 136.0448 +11996, 69.5304, 133.8402 +11997, 68.71379, 124.41 +11998, 64.83136, 127.0468 +11999, 66.67627, 127.5915 +12000, 67.08247, 118.982 +12001, 69.6942, 113.0169 +12002, 71.94501, 119.7111 +12003, 67.08849, 124.6879 +12004, 66.61029, 125.0603 +12005, 67.39237, 119.2096 +12006, 71.22979, 137.0453 +12007, 68.9821, 126.0012 +12008, 66.29932, 109.1158 +12009, 67.58579, 120.2176 +12010, 69.47049, 140.8544 +12011, 67.6955, 119.0652 +12012, 68.41184, 125.8553 +12013, 66.40097, 137.5308 +12014, 65.84222, 117.4226 +12015, 65.60355, 119.848 +12016, 68.17426, 124.7243 +12017, 68.15865, 143.2579 +12018, 70.33009, 106.6697 +12019, 64.96481, 107.2662 +12020, 70.00114, 142.0097 +12021, 73.12757, 132.9793 +12022, 69.52659, 129.1657 +12023, 65.93632, 114.5142 +12024, 68.30593, 138.0436 +12025, 69.21721, 139.1741 +12026, 69.04623, 126.3741 +12027, 66.51131, 122.9418 +12028, 68.41765, 122.2372 +12029, 67.20049, 119.9224 +12030, 70.56953, 138.8804 +12031, 67.02131, 120.5036 +12032, 60.86977, 108.8633 +12033, 69.59968, 133.8641 +12034, 66.90576, 125.7039 +12035, 65.4273, 104.4564 +12036, 65.45238, 118.7077 +12037, 66.18847, 114.58 +12038, 69.48939, 130.0937 +12039, 67.59082, 110.7189 +12040, 69.67, 119.2428 +12041, 71.81069, 132.4703 +12042, 70.21365, 139.1803 +12043, 64.64602, 111.6086 +12044, 65.31384, 123.2647 +12045, 69.30209, 143.2325 +12046, 67.21984, 126.4004 +12047, 67.89698, 105.7861 +12048, 66.44468, 128.4753 +12049, 66.30217, 125.448 +12050, 66.29508, 123.2967 +12051, 71.81034, 120.6109 +12052, 63.62293, 130.8869 +12053, 70.64303, 135.5782 +12054, 70.85476, 131.1407 +12055, 69.81498, 141.8795 +12056, 66.1487, 120.3851 +12057, 71.03088, 146.4631 +12058, 66.13556, 114.9154 +12059, 65.64932, 132.7519 +12060, 68.58104, 133.0067 +12061, 67.22079, 145.6399 +12062, 66.40365, 123.1849 +12063, 68.52532, 125.7403 +12064, 69.32648, 119.6727 +12065, 65.36659, 116.2944 +12066, 69.04615, 133.2845 +12067, 71.37994, 141.1697 +12068, 67.13772, 110.8047 +12069, 67.3967, 124.7118 +12070, 63.83814, 110.9801 +12071, 68.25068, 132.5773 +12072, 66.36931, 115.305 +12073, 70.85914, 137.5541 +12074, 67.20268, 119.3535 +12075, 65.63288, 113.8987 +12076, 71.2199, 143.6782 +12077, 67.34903, 113.7846 +12078, 67.8991, 110.5785 +12079, 65.07971, 133.4616 +12080, 69.51681, 128.293 +12081, 66.2851, 111.2819 +12082, 69.68337, 134.4863 +12083, 69.65526, 151.1571 +12084, 67.96292, 133.2323 +12085, 71.32203, 140.7135 +12086, 69.05447, 138.7171 +12087, 67.94235, 131.865 +12088, 68.32092, 127.3932 +12089, 69.87217, 129.7374 +12090, 66.83557, 137.7577 +12091, 70.46217, 154.0255 +12092, 67.69032, 133.0156 +12093, 69.10601, 133.5459 +12094, 70.29157, 128.9032 +12095, 70.35631, 116.5879 +12096, 67.3204, 106.7376 +12097, 71.18881, 145.0456 +12098, 65.71934, 130.1984 +12099, 67.40796, 120.6435 +12100, 65.05988, 111.5235 +12101, 68.22719, 108.8273 +12102, 69.53688, 135.964 +12103, 69.94726, 125.3808 +12104, 66.26851, 119.7967 +12105, 66.05849, 118.3292 +12106, 64.25245, 109.5647 +12107, 68.5623, 130.1006 +12108, 67.73521, 119.7671 +12109, 69.59796, 141.5493 +12110, 67.46095, 123.7306 +12111, 68.62535, 111.0908 +12112, 71.25126, 142.7636 +12113, 67.24688, 126.8263 +12114, 67.55773, 125.1369 +12115, 68.57922, 112.0673 +12116, 67.45327, 124.3866 +12117, 72.5565, 145.2378 +12118, 69.50107, 122.6854 +12119, 70.01967, 134.8425 +12120, 67.2572, 132.8406 +12121, 65.22247, 118.3554 +12122, 72.80624, 139.7892 +12123, 69.13179, 117.918 +12124, 67.43053, 121.0933 +12125, 67.28059, 131.4824 +12126, 70.001, 138.0392 +12127, 64.33997, 106.0198 +12128, 67.26735, 124.0488 +12129, 69.17724, 130.3436 +12130, 66.7465, 106.6506 +12131, 69.03417, 148.2146 +12132, 68.34615, 133.4005 +12133, 66.00974, 106.4586 +12134, 69.21559, 134.4881 +12135, 67.07331, 130.6017 +12136, 70.63793, 130.712 +12137, 67.24595, 135.5243 +12138, 68.10686, 117.8123 +12139, 66.90742, 111.9697 +12140, 70.15059, 158.4821 +12141, 71.65992, 136.2884 +12142, 66.80315, 125.755 +12143, 67.04952, 106.7259 +12144, 70.5931, 130.7728 +12145, 65.84071, 122.6521 +12146, 68.79573, 116.2171 +12147, 68.12082, 138.7471 +12148, 64.31209, 135.5388 +12149, 67.99862, 128.5274 +12150, 68.44172, 126.6112 +12151, 71.00788, 143.4924 +12152, 64.07458, 121.5426 +12153, 66.81797, 117.2431 +12154, 68.00128, 137.5348 +12155, 65.46423, 124.8913 +12156, 67.39722, 129.1587 +12157, 66.27501, 100.1148 +12158, 69.6573, 140.3259 +12159, 67.86229, 122.4027 +12160, 68.5617, 121.4645 +12161, 66.77693, 130.2914 +12162, 62.89638, 120.599 +12163, 67.09047, 118.2317 +12164, 67.9903, 114.796 +12165, 70.70392, 130.7639 +12166, 67.82304, 134.663 +12167, 67.15786, 114.8141 +12168, 65.92163, 115.4548 +12169, 70.02526, 125.8528 +12170, 71.12524, 140.4603 +12171, 62.74696, 126.8135 +12172, 68.94674, 140.2945 +12173, 65.25058, 127.0436 +12174, 67.14245, 120.5611 +12175, 68.68723, 130.8492 +12176, 68.62073, 145.2174 +12177, 68.11324, 116.5409 +12178, 66.86238, 119.1125 +12179, 65.40349, 101.3363 +12180, 66.2707, 103.4722 +12181, 66.86583, 116.1746 +12182, 71.66678, 134.8888 +12183, 68.00017, 125.8476 +12184, 68.66882, 139.4216 +12185, 70.35973, 129.0875 +12186, 67.76052, 131.0901 +12187, 69.21882, 134.1076 +12188, 67.74631, 105.6764 +12189, 64.15971, 129.8562 +12190, 67.62334, 110.6548 +12191, 67.89328, 117.09 +12192, 65.48471, 129.224 +12193, 68.32528, 103.4745 +12194, 68.2654, 143.7801 +12195, 72.42057, 144.387 +12196, 66.91696, 123.0398 +12197, 69.43684, 137.6724 +12198, 68.85114, 133.1969 +12199, 68.37809, 122.8097 +12200, 66.05187, 130.5855 +12201, 71.2338, 125.9994 +12202, 67.45676, 108.6551 +12203, 67.2524, 153.3825 +12204, 68.11876, 124.9622 +12205, 70.95119, 140.1531 +12206, 66.29131, 130.8994 +12207, 70.1926, 135.1047 +12208, 67.35325, 134.6156 +12209, 64.46167, 135.8058 +12210, 70.85183, 143.2765 +12211, 64.58449, 122.8244 +12212, 67.11487, 128.9426 +12213, 68.2263, 127.832 +12214, 67.15835, 127.2791 +12215, 66.82518, 132.5872 +12216, 69.46473, 119.5371 +12217, 67.51664, 125.0381 +12218, 67.11773, 118.6122 +12219, 69.12468, 136.3269 +12220, 69.29808, 118.53 +12221, 66.9325, 127.2762 +12222, 70.25476, 131.7454 +12223, 69.99264, 148.4428 +12224, 68.38126, 127.1378 +12225, 69.74475, 139.2463 +12226, 70.44609, 123.8717 +12227, 66.91785, 118.0017 +12228, 64.7893, 122.4913 +12229, 71.65016, 134.6808 +12230, 65.12654, 114.3412 +12231, 68.05579, 127.2138 +12232, 65.79014, 125.9146 +12233, 66.94808, 132.2477 +12234, 65.67741, 121.675 +12235, 69.03795, 108.3441 +12236, 69.86852, 151.5482 +12237, 64.77588, 113.1183 +12238, 70.23879, 127.2366 +12239, 67.63708, 124.7167 +12240, 67.51121, 138.459 +12241, 67.82751, 112.3725 +12242, 70.58388, 156.3417 +12243, 69.66437, 133.6791 +12244, 66.28256, 108.6047 +12245, 65.37604, 123.3283 +12246, 70.65344, 138.4873 +12247, 71.38739, 144.9405 +12248, 69.36593, 124.3237 +12249, 69.67527, 148.3828 +12250, 70.3007, 143.818 +12251, 65.16553, 115.8163 +12252, 68.33872, 132.5597 +12253, 68.38456, 123.041 +12254, 65.55581, 115.654 +12255, 70.17992, 121.6342 +12256, 67.31808, 123.3304 +12257, 68.58594, 115.2254 +12258, 72.37217, 134.1157 +12259, 70.20267, 156.1811 +12260, 68.39107, 116.6836 +12261, 70.2734, 152.4301 +12262, 69.0748, 138.6826 +12263, 68.4253, 125.4829 +12264, 66.13668, 132.1366 +12265, 67.85165, 122.8117 +12266, 66.95818, 114.1717 +12267, 65.98578, 115.7531 +12268, 67.95387, 123.3642 +12269, 66.27293, 117.9091 +12270, 68.52896, 127.998 +12271, 68.2623, 127.3359 +12272, 66.34027, 114.5888 +12273, 69.37304, 137.1683 +12274, 65.26199, 122.0038 +12275, 68.70917, 119.6392 +12276, 65.52726, 123.7422 +12277, 67.69321, 124.275 +12278, 68.9238, 136.1853 +12279, 66.1141, 113.5469 +12280, 68.06372, 127.6532 +12281, 67.59091, 116.9586 +12282, 68.92378, 121.6715 +12283, 69.89731, 148.2053 +12284, 66.99788, 114.555 +12285, 68.16828, 133.9443 +12286, 68.43843, 115.666 +12287, 67.78708, 122.3734 +12288, 69.60158, 121.3371 +12289, 68.25161, 123.1813 +12290, 66.41627, 98.73281 +12291, 68.20539, 116.9375 +12292, 69.21756, 129.3186 +12293, 64.0896, 109.3183 +12294, 66.27351, 127.1996 +12295, 65.67844, 101.6524 +12296, 68.19255, 138.3676 +12297, 69.44838, 137.7202 +12298, 67.19421, 103.7516 +12299, 67.12478, 116.941 +12300, 64.54169, 125.1319 +12301, 69.53675, 141.507 +12302, 67.2357, 122.1695 +12303, 67.95026, 129.204 +12304, 67.426, 126.447 +12305, 67.28909, 122.0906 +12306, 64.99608, 136.7717 +12307, 65.43867, 130.2553 +12308, 68.24171, 120.773 +12309, 67.04762, 119.6362 +12310, 66.53415, 112.9701 +12311, 68.88695, 121.8495 +12312, 67.83407, 138.1722 +12313, 66.37759, 123.5915 +12314, 65.36769, 119.7125 +12315, 70.68318, 135.8685 +12316, 65.49411, 141.3237 +12317, 67.91316, 121.3794 +12318, 70.79802, 126.3383 +12319, 68.51827, 128.0545 +12320, 67.47969, 126.4347 +12321, 65.24066, 123.3877 +12322, 64.32772, 118.5248 +12323, 70.41288, 152.7421 +12324, 66.6237, 115.2339 +12325, 65.90593, 108.2655 +12326, 66.52769, 112.5525 +12327, 69.31461, 126.7857 +12328, 62.87739, 103.6848 +12329, 68.92071, 130.7199 +12330, 66.13747, 108.3422 +12331, 69.99833, 122.5223 +12332, 68.46595, 138.7703 +12333, 69.25966, 133.9125 +12334, 69.93628, 128.1196 +12335, 67.01834, 123.4636 +12336, 69.77194, 130.8096 +12337, 68.65212, 139.4811 +12338, 68.44554, 111.1441 +12339, 67.88896, 118.4146 +12340, 68.68925, 121.2378 +12341, 65.56401, 105.3675 +12342, 69.20112, 139.431 +12343, 68.41482, 134.6557 +12344, 69.09655, 123.0012 +12345, 68.9416, 128.8854 +12346, 67.9139, 127.2376 +12347, 68.29377, 134.5271 +12348, 66.32216, 134.3075 +12349, 68.20057, 126.9387 +12350, 69.63237, 145.2524 +12351, 68.33465, 117.3751 +12352, 69.88231, 143.9678 +12353, 67.11991, 115.2308 +12354, 70.53097, 125.8404 +12355, 67.83481, 135.7228 +12356, 68.8196, 128.3999 +12357, 68.0312, 125.4532 +12358, 69.03316, 134.1379 +12359, 67.26332, 126.7256 +12360, 66.39875, 135.3503 +12361, 64.7363, 109.3803 +12362, 69.25052, 111.9038 +12363, 69.50292, 146.6922 +12364, 68.11694, 128.3326 +12365, 69.37864, 126.2731 +12366, 66.1219, 115.3591 +12367, 65.43542, 127.2422 +12368, 70.94749, 144.8983 +12369, 65.68418, 114.6552 +12370, 68.70422, 131.8082 +12371, 68.3036, 136.9984 +12372, 71.1963, 141.1763 +12373, 68.57603, 141.8451 +12374, 70.22202, 128.7039 +12375, 67.08514, 119.7705 +12376, 65.68889, 120.9908 +12377, 67.51772, 125.2817 +12378, 70.30046, 138.3313 +12379, 68.71184, 119.1353 +12380, 69.11819, 133.7623 +12381, 65.66806, 122.5953 +12382, 64.35738, 104.8098 +12383, 69.50005, 135.985 +12384, 67.99347, 119.7518 +12385, 68.84027, 125.351 +12386, 66.65667, 127.9004 +12387, 64.57652, 125.8364 +12388, 68.25611, 130.0452 +12389, 70.1304, 130.4494 +12390, 69.15411, 137.9543 +12391, 66.00913, 129.3445 +12392, 65.25623, 129.8806 +12393, 65.38594, 111.8541 +12394, 68.92278, 118.3422 +12395, 67.05723, 133.6179 +12396, 67.30535, 136.954 +12397, 64.88411, 140.0156 +12398, 66.28154, 100.9385 +12399, 70.93763, 135.4012 +12400, 70.63453, 133.6095 +12401, 69.46661, 128.8735 +12402, 67.96774, 143.9946 +12403, 70.0157, 134.9027 +12404, 68.46486, 102.6906 +12405, 65.54388, 108.3486 +12406, 69.57076, 134.1768 +12407, 68.70712, 122.7974 +12408, 66.47937, 126.4091 +12409, 65.6515, 138.9004 +12410, 64.8085, 118.4505 +12411, 69.20954, 128.4521 +12412, 71.2453, 140.3166 +12413, 66.78091, 133.1914 +12414, 66.66698, 118.2094 +12415, 67.46012, 130.3946 +12416, 68.39734, 132.1677 +12417, 66.05758, 106.7136 +12418, 70.74289, 129.1447 +12419, 69.0472, 112.5379 +12420, 65.25487, 113.0535 +12421, 70.83969, 136.1852 +12422, 66.48308, 129.5826 +12423, 64.86362, 131.524 +12424, 64.89809, 104.151 +12425, 66.91413, 131.8421 +12426, 68.79811, 138.0315 +12427, 68.26946, 139.016 +12428, 68.87518, 145.2094 +12429, 68.51555, 116.7877 +12430, 64.25854, 117.9964 +12431, 71.84377, 149.3361 +12432, 71.08684, 148.1875 +12433, 64.2151, 121.7215 +12434, 62.63566, 108.8842 +12435, 65.81205, 120.7095 +12436, 67.33833, 137.2586 +12437, 65.81917, 113.1984 +12438, 67.99186, 114.8133 +12439, 69.11226, 137.8176 +12440, 71.84641, 132.2059 +12441, 72.71856, 134.3143 +12442, 67.57166, 127.0006 +12443, 66.86178, 124.9583 +12444, 67.18912, 131.2947 +12445, 67.68132, 122.2843 +12446, 66.23406, 113.5248 +12447, 64.74007, 87.3791 +12448, 67.97426, 120.9928 +12449, 70.57709, 131.9995 +12450, 72.00389, 147.4338 +12451, 67.60891, 130.389 +12452, 66.68001, 118.2663 +12453, 70.70574, 124.06 +12454, 67.75154, 123.0129 +12455, 69.21119, 134.49 +12456, 70.08521, 120.7698 +12457, 68.45585, 122.5019 +12458, 68.86915, 129.1183 +12459, 67.92791, 117.2508 +12460, 70.4825, 136.7279 +12461, 69.32572, 122.6077 +12462, 67.52547, 148.9945 +12463, 65.62965, 131.0125 +12464, 67.89239, 128.1211 +12465, 68.12894, 116.1115 +12466, 69.54996, 146.4172 +12467, 66.8999, 125.8277 +12468, 67.60053, 113.744 +12469, 65.23102, 127.9767 +12470, 68.51538, 127.1196 +12471, 71.76225, 123.2438 +12472, 66.54347, 132.6527 +12473, 66.45278, 123.5997 +12474, 69.74047, 128.9735 +12475, 68.15836, 129.8696 +12476, 66.03258, 120.1757 +12477, 64.73717, 113.7689 +12478, 65.58498, 112.9359 +12479, 66.54497, 122.2424 +12480, 69.41557, 140.4464 +12481, 70.6516, 148.6669 +12482, 69.55188, 132.2138 +12483, 67.89495, 132.9517 +12484, 67.31471, 138.8578 +12485, 63.75295, 118.195 +12486, 67.2233, 125.6088 +12487, 67.54931, 126.4352 +12488, 66.91107, 122.745 +12489, 69.09424, 122.6279 +12490, 67.09958, 118.5781 +12491, 70.47341, 140.9829 +12492, 69.68349, 127.9623 +12493, 68.56579, 133.3859 +12494, 67.43454, 123.6383 +12495, 66.55213, 115.8177 +12496, 68.0387, 138.3228 +12497, 69.78338, 124.3807 +12498, 67.94391, 131.2025 +12499, 66.63849, 126.9132 +12500, 68.45079, 127.414 +12501, 70.07106, 113.5241 +12502, 69.31026, 114.3171 +12503, 71.75837, 135.6142 +12504, 69.71622, 140.662 +12505, 66.99944, 130.037 +12506, 72.48928, 138.7557 +12507, 66.28225, 117.5711 +12508, 66.00195, 130.7777 +12509, 68.5202, 118.5414 +12510, 67.26404, 121.9478 +12511, 65.81057, 120.8452 +12512, 68.39663, 140.8006 +12513, 69.54723, 139.1849 +12514, 68.82906, 126.3249 +12515, 67.68691, 121.9448 +12516, 68.60051, 110.8007 +12517, 67.02558, 127.5396 +12518, 69.32334, 139.7775 +12519, 67.76623, 123.344 +12520, 66.76197, 109.2005 +12521, 67.098, 117.2866 +12522, 68.96237, 136.63 +12523, 66.68073, 136.6551 +12524, 70.07508, 129.9514 +12525, 66.38605, 126.2915 +12526, 69.05442, 131.9593 +12527, 69.49012, 140.5831 +12528, 68.12397, 128.8785 +12529, 68.40195, 139.1229 +12530, 69.40097, 132.3228 +12531, 69.55725, 143.996 +12532, 68.71036, 126.5518 +12533, 65.21573, 116.8032 +12534, 69.36761, 135.5201 +12535, 69.12651, 139.0078 +12536, 66.89099, 137.6137 +12537, 65.4888, 134.2944 +12538, 68.20845, 135.3887 +12539, 66.29682, 111.8809 +12540, 67.53607, 111.545 +12541, 67.54041, 125.1986 +12542, 69.88988, 144.1664 +12543, 68.55332, 110.9255 +12544, 67.19021, 125.038 +12545, 67.35534, 131.0543 +12546, 71.49612, 138.8885 +12547, 68.82757, 130.4426 +12548, 69.11661, 119.6437 +12549, 64.63422, 127.7079 +12550, 64.58205, 100.557 +12551, 65.9946, 124.2257 +12552, 69.0528, 129.5877 +12553, 69.80507, 154.9924 +12554, 68.4173, 144.9684 +12555, 67.12852, 116.2219 +12556, 66.85993, 117.9136 +12557, 68.75888, 125.4433 +12558, 66.11846, 131.5019 +12559, 64.64742, 112.8034 +12560, 65.59808, 122.1915 +12561, 69.41123, 132.3657 +12562, 69.86767, 118.2363 +12563, 67.74429, 115.3566 +12564, 69.57154, 126.382 +12565, 66.93873, 126.2335 +12566, 67.32014, 130.6583 +12567, 67.45694, 113.2988 +12568, 70.22599, 135.254 +12569, 66.03134, 111.0406 +12570, 68.38498, 119.4007 +12571, 68.63206, 127.0706 +12572, 71.10527, 128.6674 +12573, 68.03731, 116.0219 +12574, 66.68726, 121.7474 +12575, 66.76614, 104.8083 +12576, 70.56704, 122.4718 +12577, 64.74464, 99.72601 +12578, 67.86554, 108.1438 +12579, 66.55172, 121.0529 +12580, 70.99403, 138.9722 +12581, 68.30178, 125.0544 +12582, 67.90843, 134.2875 +12583, 68.97747, 128.9206 +12584, 66.45071, 117.6418 +12585, 66.34292, 112.5733 +12586, 68.24008, 135.0878 +12587, 66.51948, 113.9957 +12588, 64.81528, 121.5109 +12589, 65.92603, 107.3163 +12590, 68.65183, 130.1741 +12591, 65.82599, 107.6702 +12592, 70.27704, 135.9964 +12593, 68.84244, 117.9071 +12594, 69.4594, 133.9838 +12595, 67.2644, 127.0181 +12596, 71.28234, 134.0145 +12597, 69.14869, 125.0073 +12598, 69.431, 124.9502 +12599, 71.17918, 135.0057 +12600, 66.45775, 134.571 +12601, 67.25106, 117.7898 +12602, 68.36867, 135.2021 +12603, 68.58773, 148.6514 +12604, 64.15953, 112.875 +12605, 68.69334, 138.6052 +12606, 68.72121, 148.0597 +12607, 67.7996, 130.667 +12608, 64.32884, 109.5509 +12609, 67.22786, 121.3151 +12610, 70.60144, 137.5583 +12611, 68.79806, 135.2602 +12612, 67.94924, 120.2593 +12613, 62.57873, 96.11534 +12614, 68.41549, 113.0067 +12615, 69.01353, 141.7589 +12616, 65.74831, 139.774 +12617, 71.81629, 132.7127 +12618, 69.37019, 119.1947 +12619, 66.40565, 115.9791 +12620, 70.68742, 135.3749 +12621, 66.25324, 126.0192 +12622, 68.71076, 122.2045 +12623, 67.26793, 116.1981 +12624, 69.09202, 146.6689 +12625, 72.35308, 139.6808 +12626, 69.04342, 134.08 +12627, 70.73303, 143.2831 +12628, 68.36911, 144.1253 +12629, 72.1229, 157.6616 +12630, 67.91302, 120.1835 +12631, 70.73081, 127.2146 +12632, 68.66401, 116.9992 +12633, 65.75594, 127.2348 +12634, 65.95131, 105.3219 +12635, 67.46588, 115.8773 +12636, 69.63874, 132.5026 +12637, 68.20571, 128.1029 +12638, 70.12075, 143.4512 +12639, 69.33824, 128.5652 +12640, 65.04011, 120.0564 +12641, 67.13403, 126.3556 +12642, 65.34843, 117.1063 +12643, 70.1839, 123.7718 +12644, 66.3978, 124.6117 +12645, 68.70525, 134.5751 +12646, 68.48066, 133.0611 +12647, 68.83329, 134.5825 +12648, 70.39459, 127.3152 +12649, 65.43292, 104.3383 +12650, 70.09461, 135.1397 +12651, 68.76244, 154.024 +12652, 69.35571, 128.516 +12653, 67.04356, 132.4941 +12654, 72.99632, 157.8664 +12655, 67.38058, 152.7149 +12656, 64.82189, 116.4536 +12657, 66.06893, 114.6445 +12658, 68.60001, 125.1518 +12659, 67.05224, 131.9155 +12660, 66.25923, 107.9334 +12661, 69.41316, 139.3844 +12662, 69.8588, 144.9464 +12663, 69.90593, 132.8098 +12664, 69.7052, 132.7173 +12665, 69.63663, 140.4612 +12666, 67.99399, 117.8776 +12667, 69.70857, 126.5658 +12668, 69.33609, 133.7583 +12669, 71.24983, 137.2504 +12670, 65.96176, 107.8183 +12671, 67.58381, 135.656 +12672, 69.98799, 129.377 +12673, 69.93978, 147.0146 +12674, 68.58929, 115.6961 +12675, 69.65638, 131.1921 +12676, 68.67033, 126.5642 +12677, 69.2782, 131.6396 +12678, 67.07981, 125.7229 +12679, 67.70003, 136.0609 +12680, 68.54715, 120.4416 +12681, 69.91993, 135.924 +12682, 66.98397, 126.9148 +12683, 65.48047, 108.2565 +12684, 69.07402, 130.6905 +12685, 63.83188, 114.8563 +12686, 67.4815, 122.7798 +12687, 66.69107, 106.3925 +12688, 67.34666, 122.1811 +12689, 68.28734, 116.2769 +12690, 71.91512, 132.4214 +12691, 70.24886, 133.7254 +12692, 67.30216, 137.5719 +12693, 70.24521, 126.039 +12694, 69.1209, 138.9805 +12695, 67.3079, 119.5167 +12696, 68.67791, 129.9471 +12697, 68.60468, 115.5747 +12698, 66.93601, 122.582 +12699, 69.67793, 132.9082 +12700, 66.9517, 91.22631 +12701, 68.2565, 134.6433 +12702, 70.76077, 148.3999 +12703, 70.30436, 136.2413 +12704, 69.60703, 126.7617 +12705, 66.90735, 120.1773 +12706, 64.22389, 117.6816 +12707, 64.36145, 114.8832 +12708, 71.54765, 146.309 +12709, 68.14466, 119.8608 +12710, 68.54325, 127.7214 +12711, 64.64412, 106.2843 +12712, 66.19854, 113.9223 +12713, 65.56816, 141.3379 +12714, 66.58173, 106.1254 +12715, 67.63379, 136.1838 +12716, 70.49459, 141.9638 +12717, 70.17511, 124.9465 +12718, 67.13912, 131.6294 +12719, 70.74149, 132.4381 +12720, 69.09462, 142.8177 +12721, 67.47896, 127.436 +12722, 68.55825, 143.5287 +12723, 69.07966, 147.9838 +12724, 70.35436, 121.3196 +12725, 62.70318, 92.59193 +12726, 67.59562, 138.9259 +12727, 68.14798, 140.0075 +12728, 69.27571, 155.7563 +12729, 69.07472, 120.2972 +12730, 69.09439, 117.6279 +12731, 68.6144, 130.4149 +12732, 62.398, 89.1971 +12733, 69.12922, 139.877 +12734, 67.33389, 126.0962 +12735, 65.08376, 131.736 +12736, 71.12569, 137.2863 +12737, 68.07031, 117.5196 +12738, 65.54023, 117.5058 +12739, 70.37267, 124.7668 +12740, 65.68487, 124.5331 +12741, 65.1396, 127.773 +12742, 72.15147, 148.5491 +12743, 65.05276, 103.6491 +12744, 65.00704, 95.01295 +12745, 69.52238, 134.7143 +12746, 66.51322, 114.55 +12747, 70.00383, 138.3081 +12748, 65.98143, 123.4941 +12749, 66.13459, 101.1344 +12750, 69.87842, 138.228 +12751, 66.66719, 126.0355 +12752, 66.89316, 139.7169 +12753, 68.49506, 122.879 +12754, 66.52004, 126.5041 +12755, 67.96291, 114.4191 +12756, 66.29951, 126.7682 +12757, 70.03377, 120.3446 +12758, 66.20352, 107.0425 +12759, 68.22162, 124.1618 +12760, 68.33014, 132.5046 +12761, 66.68585, 130.3999 +12762, 65.81999, 112.6146 +12763, 66.79436, 119.7033 +12764, 70.05224, 115.3835 +12765, 66.30361, 124.7241 +12766, 65.92122, 121.5372 +12767, 71.33496, 138.7443 +12768, 65.93792, 131.6449 +12769, 66.80261, 119.4744 +12770, 67.88451, 127.7094 +12771, 68.57765, 124.3734 +12772, 67.63851, 131.859 +12773, 67.44645, 128.5003 +12774, 70.78508, 132.6894 +12775, 66.20549, 114.1363 +12776, 64.01757, 101.5315 +12777, 69.51099, 144.765 +12778, 66.19759, 100.7474 +12779, 68.114, 137.3945 +12780, 68.89748, 114.6844 +12781, 66.08796, 128.0759 +12782, 65.69337, 140.7693 +12783, 66.84988, 130.5163 +12784, 68.13243, 126.5235 +12785, 65.85355, 121.6208 +12786, 66.46148, 111.3949 +12787, 70.16892, 135.7384 +12788, 70.47648, 126.461 +12789, 68.83992, 125.6376 +12790, 68.16224, 124.5737 +12791, 69.75698, 115.3657 +12792, 67.07932, 121.7021 +12793, 66.45796, 133.9175 +12794, 68.10467, 124.2443 +12795, 70.18297, 148.1467 +12796, 71.06812, 136.7636 +12797, 66.12689, 137.2242 +12798, 70.02419, 132.5 +12799, 63.95983, 110.9671 +12800, 68.29421, 138.0009 +12801, 66.78712, 125.2584 +12802, 70.31549, 118.2843 +12803, 67.87672, 115.7531 +12804, 64.98948, 115.7612 +12805, 65.73625, 103.3949 +12806, 67.18713, 113.77 +12807, 63.7027, 111.5551 +12808, 72.22326, 146.7823 +12809, 68.74167, 125.3766 +12810, 64.83708, 122.7266 +12811, 67.87607, 130.0423 +12812, 67.37786, 118.0533 +12813, 65.1186, 129.3106 +12814, 69.23622, 125.7028 +12815, 65.09077, 111.4222 +12816, 70.31072, 126.3652 +12817, 68.26941, 129.7347 +12818, 67.6398, 137.9234 +12819, 66.55938, 122.7599 +12820, 68.89767, 142.6513 +12821, 67.73688, 138.6194 +12822, 69.4266, 133.8572 +12823, 69.1415, 121.8042 +12824, 70.88688, 138.8487 +12825, 67.4992, 134.3789 +12826, 67.48566, 129.2513 +12827, 65.80458, 122.6509 +12828, 69.4832, 108.9489 +12829, 64.95436, 112.0785 +12830, 66.4238, 111.2181 +12831, 67.79983, 120.5562 +12832, 70.35784, 145.1015 +12833, 65.93427, 124.9365 +12834, 72.14741, 152.714 +12835, 69.02285, 141.9567 +12836, 67.95237, 114.0617 +12837, 64.88273, 120.3929 +12838, 66.88904, 108.9186 +12839, 68.16321, 121.259 +12840, 67.31487, 126.8506 +12841, 70.8218, 138.0774 +12842, 69.2295, 125.0231 +12843, 67.98989, 116.7557 +12844, 69.10378, 147.7595 +12845, 65.19866, 114.6411 +12846, 70.6943, 130.9471 +12847, 67.95665, 141.4925 +12848, 64.71795, 110.6855 +12849, 67.77693, 121.1735 +12850, 66.65039, 109.8503 +12851, 68.66554, 114.5278 +12852, 70.60726, 141.8837 +12853, 71.14677, 131.3756 +12854, 66.39228, 120.6284 +12855, 66.31944, 115.0054 +12856, 68.59114, 142.5636 +12857, 69.32005, 114.6814 +12858, 69.02579, 131.297 +12859, 69.92046, 135.0288 +12860, 69.21391, 109.8219 +12861, 70.50711, 135.185 +12862, 68.22468, 122.0414 +12863, 64.42053, 125.1623 +12864, 66.66605, 121.3495 +12865, 66.25687, 134.2611 +12866, 69.05579, 114.318 +12867, 63.6611, 101.3054 +12868, 65.78795, 140.3781 +12869, 65.16658, 102.3367 +12870, 68.15122, 135.4779 +12871, 69.38984, 135.9126 +12872, 65.78621, 122.6126 +12873, 68.2597, 120.6736 +12874, 69.52348, 124.3154 +12875, 68.04861, 130.1638 +12876, 65.09478, 133.7183 +12877, 67.92363, 126.3504 +12878, 67.96986, 136.9789 +12879, 68.83982, 125.9746 +12880, 66.47793, 119.8167 +12881, 69.22774, 128.9968 +12882, 66.9221, 132.8417 +12883, 68.83985, 120.0603 +12884, 71.58499, 167.8045 +12885, 68.54065, 137.9769 +12886, 66.50759, 117.7984 +12887, 69.98011, 126.927 +12888, 70.8198, 122.0349 +12889, 67.05275, 127.4661 +12890, 68.3326, 143.762 +12891, 68.9573, 132.012 +12892, 67.34256, 137.6082 +12893, 71.28917, 128.8965 +12894, 68.7694, 130.0066 +12895, 68.12962, 126.3372 +12896, 66.39812, 117.4012 +12897, 65.23885, 137.3238 +12898, 66.44001, 127.4717 +12899, 70.93311, 137.8625 +12900, 67.31072, 128.5575 +12901, 70.72584, 130.6364 +12902, 68.11148, 126.047 +12903, 68.46257, 147.0739 +12904, 68.0129, 114.4355 +12905, 66.96139, 131.5032 +12906, 68.42376, 127.3903 +12907, 69.0915, 127.5051 +12908, 67.83572, 130.7118 +12909, 67.0104, 116.4421 +12910, 67.9803, 132.8359 +12911, 69.40901, 140.1526 +12912, 68.17666, 143.5168 +12913, 68.82236, 122.6466 +12914, 69.59401, 120.2946 +12915, 69.79599, 139.6795 +12916, 69.57154, 123.7094 +12917, 66.17372, 130.3693 +12918, 68.56311, 145.1008 +12919, 68.00701, 148.8339 +12920, 68.20627, 120.9951 +12921, 68.41836, 124.8028 +12922, 66.87925, 124.0546 +12923, 67.17012, 128.4136 +12924, 67.01381, 134.9587 +12925, 66.27923, 122.9582 +12926, 66.31152, 128.7993 +12927, 67.42453, 129.8299 +12928, 67.2625, 129.1298 +12929, 66.85661, 115.8562 +12930, 68.30887, 119.1643 +12931, 67.3835, 146.1098 +12932, 70.43142, 150.9456 +12933, 69.94726, 141.3873 +12934, 69.17938, 135.8499 +12935, 66.56538, 116.9042 +12936, 68.67972, 143.4218 +12937, 64.81954, 99.80369 +12938, 70.49047, 126.5028 +12939, 68.10777, 126.735 +12940, 68.41482, 125.2798 +12941, 68.2052, 120.8053 +12942, 64.71503, 133.1455 +12943, 65.65007, 114.6888 +12944, 70.11281, 133.7564 +12945, 66.9713, 122.9566 +12946, 67.37563, 124.9457 +12947, 70.20955, 119.9669 +12948, 65.60368, 117.7954 +12949, 65.99327, 126.8598 +12950, 64.12511, 114.9245 +12951, 67.89782, 113.589 +12952, 69.76854, 126.3972 +12953, 66.68039, 123.661 +12954, 71.3082, 129.1532 +12955, 68.92387, 153.6931 +12956, 70.98202, 137.4036 +12957, 70.09326, 121.8786 +12958, 68.2703, 123.8796 +12959, 68.43097, 130.4136 +12960, 67.48521, 122.9673 +12961, 65.28618, 124.4946 +12962, 69.12615, 128.2417 +12963, 70.05579, 135.7679 +12964, 66.26599, 121.7592 +12965, 67.66477, 126.609 +12966, 67.29123, 137.2435 +12967, 68.77873, 118.0382 +12968, 69.70939, 137.5337 +12969, 70.67986, 141.8843 +12970, 69.66769, 139.9762 +12971, 67.15104, 132.4239 +12972, 68.98937, 135.7329 +12973, 67.42939, 124.1274 +12974, 67.78729, 137.1755 +12975, 64.43099, 145.4739 +12976, 67.67702, 121.8942 +12977, 69.99401, 132.7112 +12978, 69.71816, 117.6143 +12979, 69.41796, 133.882 +12980, 64.96373, 123.9581 +12981, 67.53047, 132.6457 +12982, 69.31009, 129.1492 +12983, 66.40906, 134.3405 +12984, 68.40781, 128.4416 +12985, 66.74614, 114.8763 +12986, 67.0559, 124.9848 +12987, 69.04014, 111.9708 +12988, 69.84443, 135.6318 +12989, 68.11787, 109.8296 +12990, 67.96711, 127.1728 +12991, 64.26845, 109.7383 +12992, 66.38069, 113.3612 +12993, 69.65186, 141.0062 +12994, 67.50995, 111.4264 +12995, 68.59905, 149.7418 +12996, 65.38762, 113.4099 +12997, 69.754, 139.7871 +12998, 66.40135, 122.4853 +12999, 69.97896, 119.6409 +13000, 69.31752, 133.772 +13001, 65.80662, 144.3102 +13002, 66.85982, 140.6987 +13003, 70.3717, 135.4761 +13004, 66.50564, 129.2973 +13005, 66.29807, 121.9226 +13006, 70.79659, 138.0529 +13007, 66.9188, 143.6876 +13008, 67.86452, 101.8559 +13009, 69.26225, 135.6449 +13010, 63.83449, 115.8313 +13011, 68.60409, 127.3747 +13012, 67.03402, 123.9735 +13013, 67.39559, 119.7485 +13014, 65.21454, 131.9907 +13015, 68.28765, 126.7902 +13016, 69.10579, 128.4257 +13017, 68.35335, 130.4412 +13018, 68.07782, 127.7648 +13019, 67.84152, 132.4672 +13020, 65.28594, 127.6072 +13021, 68.1933, 122.6322 +13022, 67.74053, 114.4872 +13023, 67.04758, 123.7627 +13024, 65.4041, 137.16 +13025, 66.17018, 115.5937 +13026, 66.80868, 116.272 +13027, 67.29029, 125.8577 +13028, 70.09532, 116.7931 +13029, 66.80156, 120.9025 +13030, 66.63488, 118.1354 +13031, 69.56506, 125.3899 +13032, 70.60646, 128.7028 +13033, 71.964, 130.4404 +13034, 66.99211, 106.3826 +13035, 64.63998, 124.5983 +13036, 64.46369, 113.8868 +13037, 67.48073, 118.8642 +13038, 71.0274, 149.722 +13039, 66.57652, 124.7905 +13040, 68.8576, 130.9752 +13041, 66.25434, 118.0379 +13042, 68.59622, 119.9239 +13043, 70.5651, 124.2969 +13044, 68.19129, 135.3963 +13045, 68.631, 145.9199 +13046, 66.95137, 121.817 +13047, 65.73162, 120.4355 +13048, 69.39596, 131.8885 +13049, 68.4177, 155.2243 +13050, 68.5373, 118.7651 +13051, 65.89888, 119.7408 +13052, 71.79395, 134.9478 +13053, 64.61857, 126.0336 +13054, 67.95083, 135.7588 +13055, 69.24678, 120.7578 +13056, 69.09927, 117.0254 +13057, 68.66631, 117.8159 +13058, 67.96796, 128.4943 +13059, 68.36887, 110.7174 +13060, 66.49471, 127.7524 +13061, 66.10701, 133.2153 +13062, 69.66455, 150.5807 +13063, 70.8961, 127.1952 +13064, 63.23763, 119.1795 +13065, 67.19734, 117.7393 +13066, 67.85778, 123.0461 +13067, 67.22801, 131.9317 +13068, 69.7057, 131.1593 +13069, 68.84395, 107.803 +13070, 72.34677, 133.7865 +13071, 71.26584, 134.0578 +13072, 69.44174, 122.8241 +13073, 67.29233, 118.7096 +13074, 66.81163, 101.159 +13075, 68.86359, 128.1226 +13076, 66.49126, 126.8115 +13077, 68.04236, 140.7966 +13078, 70.0192, 122.6033 +13079, 67.83242, 130.1143 +13080, 69.44946, 138.989 +13081, 67.26935, 116.3762 +13082, 66.54396, 127.1921 +13083, 70.04568, 118.2566 +13084, 66.75437, 112.4253 +13085, 64.46778, 104.1932 +13086, 66.85722, 111.022 +13087, 67.45724, 133.9342 +13088, 69.45109, 132.5114 +13089, 66.60452, 129.8988 +13090, 67.06108, 131.6097 +13091, 68.42116, 113.0609 +13092, 69.493, 116.8366 +13093, 70.46411, 140.5955 +13094, 68.9279, 112.8921 +13095, 64.0927, 122.0211 +13096, 69.8857, 120.2619 +13097, 70.98109, 133.7989 +13098, 70.75683, 134.2516 +13099, 69.29064, 122.7467 +13100, 67.34605, 118.8282 +13101, 71.60653, 145.4865 +13102, 68.73423, 127.9355 +13103, 70.23183, 132.2244 +13104, 67.73289, 128.6208 +13105, 64.52831, 119.7817 +13106, 66.63655, 116.8298 +13107, 69.76077, 116.2196 +13108, 65.56703, 127.0848 +13109, 68.77343, 121.1138 +13110, 69.40668, 140.9985 +13111, 69.43534, 137.473 +13112, 68.30511, 142.7223 +13113, 63.7744, 115.913 +13114, 65.68321, 128.3344 +13115, 68.33718, 120.9561 +13116, 69.86703, 147.7559 +13117, 65.7249, 124.3421 +13118, 68.1319, 130.2268 +13119, 70.9089, 139.7271 +13120, 67.84388, 108.6559 +13121, 67.27281, 133.2515 +13122, 66.14906, 124.3751 +13123, 67.9919, 118.8748 +13124, 67.75147, 129.3329 +13125, 69.95487, 126.1978 +13126, 65.25717, 130.0705 +13127, 68.78511, 136.2792 +13128, 68.53751, 144.8563 +13129, 66.68688, 120.6248 +13130, 65.88737, 129.3868 +13131, 67.70939, 124.5234 +13132, 63.53168, 116.9152 +13133, 69.49591, 139.4006 +13134, 70.25639, 133.0404 +13135, 68.33535, 142.8504 +13136, 68.20992, 143.3398 +13137, 71.61247, 131.4263 +13138, 68.30837, 133.0776 +13139, 68.79576, 128.3906 +13140, 66.11011, 110.656 +13141, 71.17064, 151.2357 +13142, 65.96844, 132.1259 +13143, 69.49436, 131.419 +13144, 66.1988, 130.2737 +13145, 67.05559, 124.3257 +13146, 70.82173, 136.5632 +13147, 67.84611, 136.8583 +13148, 66.01755, 112.6355 +13149, 66.2288, 124.778 +13150, 66.66816, 133.0192 +13151, 65.48562, 131.4137 +13152, 67.62, 148.1053 +13153, 68.82866, 119.503 +13154, 68.43031, 126.7202 +13155, 64.88057, 112.4524 +13156, 70.71452, 129.2147 +13157, 68.29645, 126.0144 +13158, 68.57851, 128.5564 +13159, 65.66804, 101.8834 +13160, 68.35718, 126.9565 +13161, 68.30827, 121.8879 +13162, 67.97439, 114.888 +13163, 65.44622, 110.3052 +13164, 66.41683, 135.3551 +13165, 67.76647, 107.941 +13166, 70.12719, 112.8635 +13167, 66.45294, 119.4764 +13168, 67.25909, 132.5905 +13169, 67.90183, 140.1277 +13170, 65.12247, 118.1968 +13171, 70.54615, 137.335 +13172, 67.93419, 127.8738 +13173, 68.4073, 131.5761 +13174, 68.0543, 125.3733 +13175, 66.81613, 125.5772 +13176, 71.46482, 156.698 +13177, 66.1986, 130.4507 +13178, 67.78284, 131.1426 +13179, 65.98122, 137.0717 +13180, 71.18172, 119.8668 +13181, 66.63714, 107.6969 +13182, 65.21006, 108.4938 +13183, 72.02198, 145.489 +13184, 67.73998, 130.4849 +13185, 66.80834, 118.4648 +13186, 69.82781, 151.5249 +13187, 69.066, 134.8918 +13188, 67.74345, 130.8209 +13189, 69.05112, 112.3061 +13190, 65.9683, 104.3853 +13191, 69.13584, 129.2356 +13192, 67.40931, 130.2442 +13193, 67.92429, 130.3329 +13194, 68.87862, 122.1128 +13195, 70.78535, 147.0279 +13196, 67.94063, 116.9758 +13197, 68.55731, 124.1189 +13198, 67.95809, 143.184 +13199, 67.14299, 124.7983 +13200, 66.31973, 135.487 +13201, 69.86703, 123.4288 +13202, 70.34807, 128.6677 +13203, 68.33013, 118.3628 +13204, 69.25117, 126.0558 +13205, 69.50442, 119.8007 +13206, 64.7488, 136.3069 +13207, 71.18038, 136.9996 +13208, 68.20414, 136.4564 +13209, 67.20821, 138.9231 +13210, 68.09341, 129.9965 +13211, 67.57946, 133.9151 +13212, 66.36966, 121.0705 +13213, 70.44008, 115.5771 +13214, 69.59612, 118.1955 +13215, 73.18845, 141.6274 +13216, 64.8038, 114.1008 +13217, 63.38823, 116.9479 +13218, 68.42439, 122.0094 +13219, 68.20646, 130.3053 +13220, 68.47766, 124.3275 +13221, 68.13698, 109.9892 +13222, 66.5642, 120.0656 +13223, 71.6742, 142.782 +13224, 67.05255, 128.7431 +13225, 68.85466, 117.8856 +13226, 68.65248, 122.2601 +13227, 64.16886, 110.911 +13228, 67.16001, 142.7395 +13229, 65.06853, 123.8455 +13230, 69.67259, 136.5818 +13231, 67.28347, 135.4397 +13232, 69.90543, 129.4083 +13233, 66.39269, 113.8244 +13234, 69.0075, 132.1928 +13235, 68.90949, 128.4623 +13236, 66.02741, 108.1906 +13237, 68.22004, 130.7162 +13238, 70.8693, 136.1507 +13239, 64.98984, 117.714 +13240, 67.12295, 119.9848 +13241, 67.83454, 123.3862 +13242, 70.74203, 140.0149 +13243, 64.27586, 103.4251 +13244, 68.62938, 125.9597 +13245, 71.83546, 129.9557 +13246, 69.13802, 124.1999 +13247, 69.14398, 135.7985 +13248, 69.86294, 123.7869 +13249, 68.0071, 122.3199 +13250, 64.28003, 119.2213 +13251, 64.80749, 98.27368 +13252, 68.44135, 137.1619 +13253, 67.33811, 118.3226 +13254, 66.23568, 111.8243 +13255, 65.38226, 135.7816 +13256, 69.70013, 127.6917 +13257, 70.21141, 131.4104 +13258, 67.25972, 127.8096 +13259, 68.19324, 126.6439 +13260, 69.34903, 127.2285 +13261, 70.82622, 136.3402 +13262, 68.95895, 145.2939 +13263, 66.35313, 123.3383 +13264, 67.70155, 113.0354 +13265, 66.01282, 126.4426 +13266, 64.67146, 121.8473 +13267, 65.26196, 116.2627 +13268, 64.32105, 126.3531 +13269, 68.19311, 114.3672 +13270, 70.63372, 138.5337 +13271, 67.32161, 137.0611 +13272, 69.07423, 134.9462 +13273, 67.38292, 112.8386 +13274, 66.9492, 110.6838 +13275, 69.37345, 135.2223 +13276, 67.17327, 128.3909 +13277, 64.82297, 113.3591 +13278, 69.74366, 131.9008 +13279, 69.05523, 122.8494 +13280, 68.52817, 119.1168 +13281, 65.77416, 135.7006 +13282, 70.49366, 129.384 +13283, 71.53026, 135.0245 +13284, 68.16348, 110.3596 +13285, 70.15896, 153.1741 +13286, 68.67804, 141.0451 +13287, 64.07479, 118.5714 +13288, 65.63973, 99.81515 +13289, 67.91191, 129.3775 +13290, 67.775, 146.1935 +13291, 69.18617, 132.9471 +13292, 68.01384, 131.7207 +13293, 62.48941, 117.7949 +13294, 67.96079, 127.3995 +13295, 67.82376, 134.2977 +13296, 66.92886, 111.183 +13297, 67.39775, 134.5976 +13298, 67.41853, 143.8567 +13299, 66.08383, 118.2815 +13300, 69.40233, 119.7774 +13301, 68.42976, 124.3332 +13302, 68.65284, 126.7226 +13303, 67.71085, 110.5105 +13304, 66.92357, 113.5576 +13305, 67.28097, 128.3507 +13306, 67.60201, 132.2953 +13307, 69.39436, 120.7939 +13308, 66.10454, 113.4298 +13309, 68.63883, 129.8796 +13310, 66.93124, 119.3294 +13311, 66.52196, 134.1469 +13312, 64.39478, 118.0702 +13313, 67.87061, 127.3809 +13314, 70.43201, 121.1751 +13315, 70.40373, 118.6765 +13316, 68.88718, 127.3501 +13317, 69.10626, 124.0148 +13318, 69.20993, 131.5479 +13319, 66.95677, 127.1894 +13320, 68.55278, 139.2787 +13321, 67.34935, 121.2197 +13322, 70.08442, 146.126 +13323, 66.55493, 120.4965 +13324, 68.39772, 134.5794 +13325, 69.17551, 127.7031 +13326, 67.88832, 130.9674 +13327, 69.23136, 151.7222 +13328, 66.39321, 136.1953 +13329, 66.29156, 129.0251 +13330, 69.27872, 133.8416 +13331, 67.04849, 123.7323 +13332, 66.08908, 120.447 +13333, 65.40789, 106.4048 +13334, 64.41176, 100.5481 +13335, 68.99911, 147.0279 +13336, 63.96038, 98.96049 +13337, 67.25019, 111.6628 +13338, 70.13072, 138.9752 +13339, 73.11393, 154.7801 +13340, 68.46228, 135.4161 +13341, 69.36312, 131.0502 +13342, 64.95313, 113.1035 +13343, 66.01722, 106.2152 +13344, 66.2941, 114.7051 +13345, 70.67693, 125.1185 +13346, 67.33243, 135.8197 +13347, 63.68425, 127.6135 +13348, 67.05486, 125.9922 +13349, 71.57334, 125.7925 +13350, 70.74414, 149.5795 +13351, 67.90413, 123.895 +13352, 70.23876, 134.9732 +13353, 66.42802, 143.3147 +13354, 68.27668, 120.5478 +13355, 69.23481, 132.964 +13356, 66.24127, 124.8096 +13357, 71.24159, 150.798 +13358, 64.23067, 106.6067 +13359, 68.13972, 129.562 +13360, 70.5219, 138.8618 +13361, 68.80228, 123.557 +13362, 71.47939, 122.5102 +13363, 66.25554, 117.2567 +13364, 67.65893, 125.1901 +13365, 66.24544, 118.1862 +13366, 69.4015, 117.9695 +13367, 63.68623, 124.7147 +13368, 67.70352, 117.4804 +13369, 64.58855, 97.81632 +13370, 67.90312, 121.7761 +13371, 69.31825, 132.5327 +13372, 68.78074, 133.8886 +13373, 65.16747, 103.7879 +13374, 67.39659, 123.8458 +13375, 64.41103, 100.447 +13376, 71.47445, 139.9332 +13377, 66.08011, 114.2059 +13378, 69.12359, 127.9635 +13379, 70.18251, 142.0535 +13380, 69.52844, 149.3159 +13381, 65.45636, 124.7121 +13382, 72.1365, 133.2988 +13383, 64.01521, 112.954 +13384, 66.94399, 121.8452 +13385, 70.76624, 129.2601 +13386, 67.1248, 127.1223 +13387, 70.91403, 137.6657 +13388, 69.05992, 96.98373 +13389, 68.87014, 132.286 +13390, 70.56427, 139.1888 +13391, 68.74068, 140.9494 +13392, 66.04751, 133.5623 +13393, 71.5113, 131.3287 +13394, 67.61109, 131.3793 +13395, 67.65123, 120.4534 +13396, 69.26124, 130.3283 +13397, 68.05308, 111.5429 +13398, 70.66922, 120.3896 +13399, 63.44163, 115.5336 +13400, 66.15659, 114.6908 +13401, 68.17946, 146.4593 +13402, 67.26248, 122.2184 +13403, 69.54205, 135.2309 +13404, 68.23248, 117.6804 +13405, 68.37902, 133.9223 +13406, 63.64125, 112.1593 +13407, 71.46636, 141.1508 +13408, 69.26616, 140.8013 +13409, 69.24025, 155.7611 +13410, 67.95744, 121.5092 +13411, 66.88315, 123.9898 +13412, 69.59355, 130.8852 +13413, 70.21228, 136.9528 +13414, 66.76888, 109.2297 +13415, 67.03536, 134.7424 +13416, 72.72333, 135.6775 +13417, 71.27092, 149.2486 +13418, 70.04237, 120.8985 +13419, 67.30938, 125.4023 +13420, 70.92362, 142.0399 +13421, 70.86617, 136.8164 +13422, 71.16906, 125.1008 +13423, 71.27803, 126.8942 +13424, 69.02346, 134.2947 +13425, 70.32898, 142.0952 +13426, 64.65613, 110.0386 +13427, 68.30144, 116.1683 +13428, 68.02501, 129.2719 +13429, 69.54645, 135.4922 +13430, 69.66515, 120.5153 +13431, 66.61978, 120.8916 +13432, 70.70351, 144.7056 +13433, 66.84578, 123.4342 +13434, 66.91022, 104.7945 +13435, 70.46769, 117.2765 +13436, 67.7792, 125.5647 +13437, 65.6698, 107.2109 +13438, 66.92797, 132.8552 +13439, 66.83788, 142.0706 +13440, 66.2109, 125.9366 +13441, 71.51674, 137.7854 +13442, 69.25899, 127.4162 +13443, 66.38182, 128.5337 +13444, 67.98866, 103.9803 +13445, 69.10657, 121.7137 +13446, 66.93244, 128.6671 +13447, 68.78738, 111.3942 +13448, 71.69889, 127.9976 +13449, 71.58625, 155.8226 +13450, 70.22459, 123.7852 +13451, 67.80333, 129.0836 +13452, 66.99804, 141.1636 +13453, 66.69938, 126.4284 +13454, 67.81842, 107.4346 +13455, 65.52188, 102.8837 +13456, 66.26517, 112.6468 +13457, 66.61056, 132.1592 +13458, 69.2276, 135.7117 +13459, 69.76883, 131.289 +13460, 67.25415, 126.2261 +13461, 71.94325, 146.1599 +13462, 70.42889, 131.4166 +13463, 69.14838, 135.2424 +13464, 66.35698, 117.5543 +13465, 67.72308, 120.2195 +13466, 69.32816, 144.6047 +13467, 67.18685, 119.0143 +13468, 64.98016, 128.0163 +13469, 69.50141, 131.0541 +13470, 66.21749, 117.7252 +13471, 66.87048, 146.4228 +13472, 67.26667, 110.8618 +13473, 68.84698, 118.8636 +13474, 69.64577, 137.3837 +13475, 68.42511, 127.5529 +13476, 66.12824, 130.6234 +13477, 66.50649, 118.7096 +13478, 68.22237, 117.7128 +13479, 70.89547, 132.2301 +13480, 66.49191, 129.8035 +13481, 65.92614, 110.2858 +13482, 70.60162, 133.4747 +13483, 69.90771, 125.1461 +13484, 68.17237, 135.0448 +13485, 67.93822, 114.7389 +13486, 67.26702, 127.2478 +13487, 70.93422, 134.1138 +13488, 65.43279, 132.7763 +13489, 68.50404, 136.0545 +13490, 65.32412, 124.1597 +13491, 67.15877, 124.869 +13492, 64.08903, 104.5371 +13493, 64.87852, 119.364 +13494, 68.06382, 112.3071 +13495, 67.85512, 138.274 +13496, 68.69451, 136.9217 +13497, 71.83913, 138.6279 +13498, 72.68296, 134.195 +13499, 72.97709, 129.5139 +13500, 68.69342, 111.9045 +13501, 68.68038, 125.2037 +13502, 70.61549, 135.1449 +13503, 68.58312, 133.3172 +13504, 67.87132, 122.0944 +13505, 67.36301, 133.484 +13506, 70.012, 125.7454 +13507, 71.00838, 140.3572 +13508, 69.54254, 153.5616 +13509, 67.29908, 126.9459 +13510, 68.91619, 133.2555 +13511, 66.98198, 110.6282 +13512, 67.52527, 131.6131 +13513, 68.68913, 153.1047 +13514, 68.0705, 145.1079 +13515, 65.34667, 106.6298 +13516, 68.27458, 129.4259 +13517, 68.43948, 138.6668 +13518, 68.63517, 125.4484 +13519, 65.9169, 115.5298 +13520, 68.75507, 121.4015 +13521, 67.50336, 121.0915 +13522, 67.35686, 119.5916 +13523, 68.74911, 123.4175 +13524, 65.82688, 125.1802 +13525, 63.66383, 100.9581 +13526, 66.73418, 123.5122 +13527, 68.7669, 121.9292 +13528, 63.50262, 115.3714 +13529, 67.76649, 125.1451 +13530, 68.57622, 123.7199 +13531, 69.26441, 135.5441 +13532, 69.68345, 122.2247 +13533, 68.79655, 124.5403 +13534, 71.45548, 149.4462 +13535, 67.08221, 107.519 +13536, 66.30983, 107.8446 +13537, 67.05289, 130.3873 +13538, 66.69178, 112.7728 +13539, 67.73043, 122.5769 +13540, 68.00003, 137.312 +13541, 66.63813, 102.5589 +13542, 65.65274, 108.267 +13543, 69.22019, 113.4516 +13544, 64.23796, 127.21 +13545, 67.5943, 133.0013 +13546, 70.42984, 136.3197 +13547, 67.11274, 128.19 +13548, 67.98772, 113.4182 +13549, 69.89944, 143.3529 +13550, 67.47588, 118.6167 +13551, 70.73882, 133.249 +13552, 67.09517, 127.4636 +13553, 64.63916, 124.0617 +13554, 65.95318, 114.1656 +13555, 70.34111, 131.5517 +13556, 65.08001, 117.1925 +13557, 67.01532, 127.5686 +13558, 67.44816, 140.1632 +13559, 64.62936, 114.2821 +13560, 67.18612, 128.9279 +13561, 69.1269, 125.3568 +13562, 67.48529, 111.7304 +13563, 68.60783, 133.3954 +13564, 66.35991, 111.3237 +13565, 67.23519, 123.6025 +13566, 68.10568, 124.4485 +13567, 64.73949, 138.3973 +13568, 68.29833, 127.7477 +13569, 69.22544, 131.9046 +13570, 68.59662, 142.6983 +13571, 66.28389, 120.2258 +13572, 66.43058, 112.2964 +13573, 64.0014, 116.3801 +13574, 67.44234, 152.4923 +13575, 65.15728, 102.1984 +13576, 65.33919, 112.9692 +13577, 65.70654, 130.7918 +13578, 64.35914, 112.2244 +13579, 65.57652, 126.7799 +13580, 71.05843, 136.3315 +13581, 67.23561, 122.0408 +13582, 65.16695, 110.5248 +13583, 69.84415, 152.3574 +13584, 66.61845, 124.8794 +13585, 67.50831, 150.5015 +13586, 66.40242, 124.3254 +13587, 69.02896, 123.8979 +13588, 69.10557, 149.6609 +13589, 68.44275, 126.72 +13590, 68.64999, 139.3151 +13591, 72.40603, 131.9203 +13592, 67.91361, 132.3644 +13593, 66.90988, 116.3878 +13594, 66.08598, 134.0194 +13595, 67.66889, 121.2939 +13596, 68.76862, 131.9744 +13597, 66.98014, 117.2521 +13598, 68.74833, 125.9501 +13599, 70.79517, 133.642 +13600, 64.31269, 110.4079 +13601, 68.92165, 120.3599 +13602, 67.70132, 137.2192 +13603, 71.41874, 139.3438 +13604, 72.51415, 114.3909 +13605, 68.8114, 127.7579 +13606, 67.13979, 109.7144 +13607, 66.74072, 130.6229 +13608, 69.70146, 156.5445 +13609, 72.75144, 157.7481 +13610, 67.66406, 139.4558 +13611, 68.27904, 144.4879 +13612, 69.24852, 136.1629 +13613, 70.34305, 138.67 +13614, 72.09527, 135.252 +13615, 67.11737, 127.7587 +13616, 71.75284, 138.0633 +13617, 66.32216, 123.6735 +13618, 68.59531, 128.7746 +13619, 67.84571, 129.0955 +13620, 69.33815, 118.5346 +13621, 66.37336, 122.3126 +13622, 66.26652, 110.3988 +13623, 64.87171, 132.5079 +13624, 67.92885, 109.6037 +13625, 70.33507, 153.9626 +13626, 66.34491, 120.7221 +13627, 68.64508, 137.0787 +13628, 67.34987, 120.2499 +13629, 69.2373, 132.8112 +13630, 69.88961, 131.3 +13631, 65.71516, 125.3647 +13632, 69.20236, 137.538 +13633, 72.83266, 143.9874 +13634, 63.90262, 122.0885 +13635, 65.38753, 125.0461 +13636, 65.11627, 123.6793 +13637, 68.0761, 125.6445 +13638, 70.38111, 143.9183 +13639, 68.29328, 125.3891 +13640, 66.17228, 121.1097 +13641, 69.01299, 126.3802 +13642, 64.39616, 118.3443 +13643, 69.66799, 137.5244 +13644, 70.11684, 148.1291 +13645, 70.67615, 138.4174 +13646, 71.67171, 154.5974 +13647, 70.98541, 132.011 +13648, 68.69251, 120.464 +13649, 66.13051, 130.6484 +13650, 72.18172, 145.7772 +13651, 64.49398, 120.2569 +13652, 71.09941, 120.904 +13653, 68.20045, 130.0656 +13654, 66.33023, 113.2041 +13655, 67.04367, 138.0165 +13656, 68.30547, 127.9004 +13657, 69.18392, 125.2414 +13658, 68.03723, 135.8445 +13659, 66.57552, 133.4506 +13660, 67.96196, 126.5701 +13661, 70.04325, 131.8625 +13662, 66.82989, 136.6633 +13663, 66.06785, 119.3338 +13664, 66.73451, 114.521 +13665, 68.59738, 131.6491 +13666, 67.93096, 118.3885 +13667, 68.29048, 140.8166 +13668, 65.61713, 136.7163 +13669, 68.83511, 133.5565 +13670, 68.41749, 121.6358 +13671, 68.29963, 125.9208 +13672, 67.07739, 120.9513 +13673, 65.28695, 127.0931 +13674, 69.56663, 132.7942 +13675, 69.96385, 139.112 +13676, 71.49172, 156.6047 +13677, 72.06918, 130.0836 +13678, 68.32088, 136.4392 +13679, 69.41193, 124.4338 +13680, 69.30554, 141.7445 +13681, 70.28825, 149.8366 +13682, 74.74047, 155.5462 +13683, 67.89908, 128.0993 +13684, 63.31957, 124.2271 +13685, 68.88209, 117.1974 +13686, 66.09881, 117.9989 +13687, 68.39956, 135.4289 +13688, 65.81467, 119.0041 +13689, 66.51669, 123.0958 +13690, 66.68897, 128.9492 +13691, 68.85866, 122.1515 +13692, 65.28602, 117.6903 +13693, 67.45382, 121.8754 +13694, 65.72572, 104.7868 +13695, 69.1809, 138.1944 +13696, 67.19123, 119.7814 +13697, 67.95791, 115.3964 +13698, 69.90153, 133.6208 +13699, 69.36667, 120.1496 +13700, 68.2609, 123.5765 +13701, 67.73458, 123.3573 +13702, 67.99545, 124.5313 +13703, 67.02058, 120.1386 +13704, 68.0984, 118.3992 +13705, 69.07483, 136.2293 +13706, 68.55788, 150.1478 +13707, 67.88128, 91.79628 +13708, 64.57218, 117.3649 +13709, 65.66127, 111.9679 +13710, 67.40301, 122.1909 +13711, 67.55072, 136.2613 +13712, 66.3712, 110.5685 +13713, 69.03177, 140.8798 +13714, 69.56693, 139.21 +13715, 67.997, 142.6499 +13716, 67.77191, 116.9825 +13717, 70.25823, 146.4642 +13718, 67.55181, 129.5468 +13719, 68.46142, 123.4447 +13720, 66.27821, 118.7967 +13721, 67.16134, 128.4656 +13722, 70.74503, 127.2149 +13723, 64.41245, 130.2909 +13724, 69.93806, 135.9627 +13725, 66.89486, 141.925 +13726, 69.35583, 129.5942 +13727, 70.31031, 115.0746 +13728, 65.16672, 108.6499 +13729, 66.13636, 116.5107 +13730, 69.9459, 118.4187 +13731, 65.77942, 130.5573 +13732, 65.37242, 123.4043 +13733, 67.52532, 112.6009 +13734, 65.66027, 130.1065 +13735, 68.08438, 125.6412 +13736, 70.20405, 141.2656 +13737, 68.09138, 126.8049 +13738, 69.8622, 130.7656 +13739, 71.2364, 165.4348 +13740, 67.73715, 118.1487 +13741, 68.97119, 139.1271 +13742, 65.20052, 116.3499 +13743, 68.44766, 143.052 +13744, 69.85374, 123.8261 +13745, 68.53738, 133.8745 +13746, 67.83017, 131.8549 +13747, 66.23251, 127.9094 +13748, 65.89304, 115.487 +13749, 65.6772, 121.1499 +13750, 66.76883, 136.4819 +13751, 69.74836, 122.1892 +13752, 66.02269, 110.8825 +13753, 67.8839, 142.7609 +13754, 67.9508, 132.0453 +13755, 68.08386, 129.7618 +13756, 67.34271, 116.0603 +13757, 68.1341, 112.7088 +13758, 70.01101, 140.5868 +13759, 67.81576, 132.5872 +13760, 71.44931, 152.6402 +13761, 66.86293, 132.6471 +13762, 66.96378, 97.03296 +13763, 70.86922, 142.2524 +13764, 66.07424, 124.2275 +13765, 63.1202, 131.0273 +13766, 66.13073, 123.7088 +13767, 68.49757, 128.567 +13768, 67.64703, 126.1548 +13769, 64.13542, 111.5291 +13770, 65.18415, 111.5203 +13771, 65.28989, 102.8829 +13772, 66.93899, 130.9771 +13773, 69.76519, 131.7523 +13774, 70.14971, 131.6752 +13775, 69.76427, 128.3103 +13776, 66.79976, 111.8919 +13777, 64.24878, 111.8224 +13778, 66.26232, 130.8118 +13779, 67.36842, 140.4376 +13780, 69.54224, 136.2962 +13781, 70.7088, 135.0448 +13782, 68.30583, 107.0114 +13783, 68.77584, 115.0584 +13784, 64.57222, 110.4544 +13785, 70.37127, 131.4099 +13786, 65.67011, 126.3269 +13787, 70.20753, 146.1756 +13788, 64.77025, 121.1153 +13789, 71.3765, 137.7634 +13790, 67.69573, 141.5469 +13791, 67.51762, 124.1185 +13792, 67.19765, 137.8119 +13793, 67.1093, 133.0114 +13794, 69.1917, 123.958 +13795, 69.15525, 119.1435 +13796, 69.86536, 121.2642 +13797, 66.32886, 127.9168 +13798, 67.86215, 121.1058 +13799, 68.27113, 116.4098 +13800, 65.76944, 126.6246 +13801, 67.92933, 130.5733 +13802, 71.2216, 123.3636 +13803, 66.912, 119.4482 +13804, 67.41402, 131.0606 +13805, 67.22463, 119.8691 +13806, 68.55061, 134.7133 +13807, 70.89052, 141.621 +13808, 64.97357, 100.993 +13809, 67.54977, 115.0079 +13810, 69.25733, 147.6032 +13811, 68.42616, 141.9304 +13812, 66.83894, 128.7245 +13813, 69.12521, 123.8116 +13814, 65.94202, 126.6764 +13815, 69.15548, 137.3675 +13816, 66.63132, 130.1165 +13817, 69.7449, 122.1703 +13818, 68.182, 125.3675 +13819, 63.34895, 108.9061 +13820, 65.91937, 120.2951 +13821, 68.34026, 117.7427 +13822, 69.17937, 147.5066 +13823, 65.73096, 124.0377 +13824, 65.25774, 137.7447 +13825, 66.95904, 117.1612 +13826, 67.46686, 102.788 +13827, 64.5303, 109.287 +13828, 68.22274, 106.3999 +13829, 69.74043, 149.3723 +13830, 66.82473, 115.1647 +13831, 66.7667, 106.6478 +13832, 66.60791, 104.4031 +13833, 66.22167, 106.6763 +13834, 66.96213, 126.4268 +13835, 70.45353, 144.5438 +13836, 71.72731, 127.6123 +13837, 69.12426, 136.6216 +13838, 68.64719, 125.4496 +13839, 65.7677, 112.6545 +13840, 69.92728, 137.5083 +13841, 66.95014, 131.6857 +13842, 68.99774, 143.0834 +13843, 71.31319, 127.6948 +13844, 65.88245, 131.4081 +13845, 68.39531, 117.7972 +13846, 69.5689, 133.7194 +13847, 69.82927, 127.2561 +13848, 67.95272, 111.2289 +13849, 68.98352, 133.427 +13850, 65.59897, 111.5773 +13851, 66.58067, 146.9392 +13852, 67.7046, 133.8558 +13853, 69.99147, 144.8165 +13854, 69.95446, 121.3657 +13855, 69.13713, 129.0169 +13856, 67.36034, 123.4454 +13857, 64.50897, 104.6736 +13858, 64.64068, 112.5689 +13859, 69.21305, 134.9969 +13860, 70.40988, 141.6769 +13861, 68.39682, 130.6472 +13862, 69.95437, 150.2712 +13863, 67.70414, 129.5662 +13864, 70.21315, 143.1277 +13865, 71.55881, 140.8115 +13866, 65.74844, 118.1262 +13867, 65.92318, 115.5208 +13868, 68.39851, 139.0805 +13869, 67.13347, 117.7219 +13870, 69.06374, 113.4222 +13871, 69.31382, 107.9401 +13872, 68.40244, 130.7315 +13873, 66.16601, 109.7068 +13874, 68.7271, 134.0751 +13875, 67.8651, 100.6523 +13876, 65.13709, 103.7386 +13877, 68.3908, 128.9968 +13878, 69.0989, 140.9024 +13879, 70.78829, 116.0327 +13880, 66.82614, 103.8567 +13881, 68.51919, 135.0276 +13882, 63.42416, 115.1669 +13883, 68.67133, 138.4376 +13884, 68.69668, 141.5566 +13885, 68.74929, 132.1818 +13886, 67.80121, 149.1847 +13887, 66.66077, 133.2206 +13888, 65.65457, 125.0592 +13889, 67.32239, 123.0962 +13890, 65.64744, 135.0891 +13891, 66.16885, 115.675 +13892, 68.84435, 129.7317 +13893, 70.3845, 132.3889 +13894, 64.15154, 121.0638 +13895, 65.93081, 121.1675 +13896, 66.42939, 124.7448 +13897, 67.0965, 128.85 +13898, 67.67338, 118.6532 +13899, 67.32413, 135.3278 +13900, 70.519, 129.3913 +13901, 66.28763, 124.8871 +13902, 66.89899, 131.4067 +13903, 68.60623, 129.9693 +13904, 65.64473, 111.3161 +13905, 67.57584, 116.4266 +13906, 67.27226, 117.229 +13907, 68.58803, 143.4394 +13908, 69.20003, 131.5186 +13909, 69.54645, 115.0614 +13910, 66.96253, 110.8142 +13911, 64.22288, 124.7478 +13912, 65.11698, 129.2592 +13913, 67.36456, 123.3457 +13914, 67.49718, 124.9092 +13915, 68.31028, 142.7313 +13916, 70.80122, 127.9696 +13917, 66.93479, 133.0576 +13918, 67.75842, 131.14 +13919, 63.81449, 119.4379 +13920, 68.51883, 132.3252 +13921, 70.23493, 125.7225 +13922, 68.61403, 133.7697 +13923, 68.03872, 136.8378 +13924, 69.29088, 122.7787 +13925, 71.26954, 135.0683 +13926, 64.91601, 110.2655 +13927, 67.18613, 124.0557 +13928, 70.79073, 125.8297 +13929, 69.88144, 129.0521 +13930, 66.10857, 122.8552 +13931, 70.34043, 129.3487 +13932, 70.71954, 128.7553 +13933, 68.49864, 113.5357 +13934, 64.68471, 118.1635 +13935, 67.81336, 125.1218 +13936, 67.32677, 116.7349 +13937, 70.80715, 139.2165 +13938, 68.27181, 133.8987 +13939, 67.79985, 144.0007 +13940, 70.24363, 127.7861 +13941, 69.0627, 108.916 +13942, 68.64606, 109.8435 +13943, 68.43749, 122.3513 +13944, 66.564, 118.0219 +13945, 68.73434, 132.5926 +13946, 70.34988, 131.2347 +13947, 68.32147, 132.9566 +13948, 68.85217, 150.0004 +13949, 70.0906, 138.4704 +13950, 71.53276, 125.8273 +13951, 68.42484, 131.4501 +13952, 68.58043, 122.8021 +13953, 68.58863, 121.4833 +13954, 66.78852, 125.8598 +13955, 71.05294, 140.8371 +13956, 67.87961, 119.2717 +13957, 68.17244, 135.1764 +13958, 70.42742, 141.1003 +13959, 67.19885, 119.4295 +13960, 68.59893, 123.1239 +13961, 68.32595, 117.3794 +13962, 65.62714, 121.2559 +13963, 70.04301, 154.9343 +13964, 68.38119, 122.0905 +13965, 67.52926, 126.9393 +13966, 68.10619, 124.0167 +13967, 65.46141, 108.8987 +13968, 67.06246, 128.834 +13969, 65.34267, 129.1537 +13970, 70.5704, 130.5011 +13971, 72.34839, 157.8066 +13972, 60.27836, 110.1138 +13973, 67.61855, 103.0198 +13974, 71.49569, 144.1566 +13975, 68.74794, 124.4705 +13976, 69.91849, 135.1641 +13977, 65.19504, 112.8648 +13978, 68.38232, 126.0162 +13979, 67.25518, 122.1221 +13980, 68.93483, 127.7623 +13981, 68.44699, 123.1308 +13982, 66.32658, 132.9695 +13983, 69.33376, 117.9713 +13984, 67.53281, 125.2872 +13985, 70.46549, 125.7753 +13986, 66.48216, 114.7755 +13987, 65.5645, 124.9968 +13988, 68.55191, 136.3553 +13989, 69.95594, 139.5419 +13990, 69.92062, 140.3966 +13991, 67.83218, 133.3225 +13992, 67.42913, 130.3175 +13993, 66.70177, 124.9376 +13994, 70.21284, 122.9461 +13995, 67.96958, 126.7309 +13996, 67.92194, 120.0718 +13997, 68.80637, 134.3642 +13998, 69.10289, 139.7602 +13999, 70.25784, 123.1635 +14000, 66.35824, 122.6852 +14001, 66.29874, 118.2763 +14002, 69.23979, 134.1059 +14003, 69.96459, 123.4101 +14004, 70.33325, 130.2675 +14005, 67.8791, 123.0713 +14006, 69.80115, 140.0347 +14007, 71.85087, 149.4641 +14008, 68.86095, 135.3824 +14009, 68.26626, 139.32 +14010, 68.22977, 132.8191 +14011, 68.87266, 134.2836 +14012, 68.69331, 119.1176 +14013, 69.50191, 124.9842 +14014, 67.13278, 126.6367 +14015, 68.07784, 112.9545 +14016, 65.60161, 132.3679 +14017, 66.25651, 108.6773 +14018, 65.57211, 117.4159 +14019, 69.01055, 100.181 +14020, 64.2501, 107.6959 +14021, 70.00883, 129.8113 +14022, 67.42102, 147.3407 +14023, 65.37725, 142.2231 +14024, 66.4546, 122.3176 +14025, 66.25961, 135.4493 +14026, 64.69471, 112.4972 +14027, 70.89926, 149.3595 +14028, 67.05572, 126.9729 +14029, 66.16531, 132.4495 +14030, 67.22303, 135.8181 +14031, 69.51503, 124.8695 +14032, 65.44081, 115.6159 +14033, 66.5001, 109.6408 +14034, 66.04055, 121.2501 +14035, 67.5518, 132.2297 +14036, 69.06258, 129.0295 +14037, 65.86704, 129.4721 +14038, 66.38913, 136.9183 +14039, 67.06884, 123.9572 +14040, 65.41938, 119.476 +14041, 70.53863, 128.5198 +14042, 66.42745, 128.774 +14043, 67.52661, 121.3385 +14044, 70.4217, 123.358 +14045, 69.38026, 130.7818 +14046, 66.94303, 134.8107 +14047, 66.50907, 123.5263 +14048, 67.29972, 128.9403 +14049, 69.81584, 139.2252 +14050, 67.38016, 120.8477 +14051, 67.70214, 126.4529 +14052, 69.10227, 130.6785 +14053, 67.94031, 121.4563 +14054, 68.26271, 123.7273 +14055, 67.5991, 132.0902 +14056, 70.1651, 143.8473 +14057, 68.83927, 134.9782 +14058, 68.96635, 117.2842 +14059, 67.11342, 128.5372 +14060, 67.68551, 121.7078 +14061, 66.45664, 123.3311 +14062, 66.89404, 106.7602 +14063, 69.61824, 120.5271 +14064, 74.04804, 149.6303 +14065, 69.64822, 142.7772 +14066, 68.92365, 115.4178 +14067, 67.36277, 119.6295 +14068, 68.34878, 134.3189 +14069, 66.00426, 128.4332 +14070, 69.14864, 126.6413 +14071, 68.49425, 117.5148 +14072, 68.06637, 134.2341 +14073, 72.93887, 144.9647 +14074, 66.18115, 132.6478 +14075, 67.99965, 119.7057 +14076, 66.96461, 117.8036 +14077, 67.74233, 137.5251 +14078, 67.25235, 127.1944 +14079, 68.93064, 118.6825 +14080, 67.66692, 122.408 +14081, 68.36323, 127.859 +14082, 68.5151, 124.2807 +14083, 68.59649, 126.3488 +14084, 67.89703, 117.1268 +14085, 68.54559, 123.3066 +14086, 68.57763, 130.224 +14087, 65.30062, 129.1373 +14088, 69.64468, 132.1716 +14089, 68.60546, 139.3675 +14090, 66.67257, 120.0443 +14091, 67.51525, 135.3145 +14092, 69.19989, 128.2222 +14093, 69.93288, 144.365 +14094, 67.73185, 129.3353 +14095, 69.01928, 126.148 +14096, 68.85323, 122.8646 +14097, 64.28729, 107.047 +14098, 72.16006, 143.1819 +14099, 67.89779, 141.3709 +14100, 69.10375, 122.7892 +14101, 65.65523, 137.5148 +14102, 68.82547, 117.8694 +14103, 68.48097, 122.2078 +14104, 66.68648, 117.8087 +14105, 66.62504, 126.9058 +14106, 64.97433, 103.1333 +14107, 61.90725, 78.56785 +14108, 66.97721, 139.1241 +14109, 66.48817, 111.8809 +14110, 66.08182, 128.2333 +14111, 67.8436, 120.26 +14112, 68.57876, 148.3076 +14113, 68.22504, 142.7289 +14114, 65.79376, 113.9473 +14115, 69.42855, 137.6963 +14116, 69.73313, 128.2394 +14117, 66.27846, 96.95428 +14118, 70.91261, 149.4527 +14119, 69.76864, 138.425 +14120, 66.6929, 123.4958 +14121, 67.84359, 138.9076 +14122, 69.76751, 123.4689 +14123, 70.53942, 148.3832 +14124, 68.88232, 134.5561 +14125, 67.76694, 132.0017 +14126, 69.68007, 115.6036 +14127, 70.30177, 114.5099 +14128, 68.39681, 131.135 +14129, 68.67559, 137.2308 +14130, 67.25836, 113.6762 +14131, 68.33766, 135.9751 +14132, 68.73641, 133.9187 +14133, 69.74424, 135.1867 +14134, 66.69188, 119.4333 +14135, 62.52876, 108.1177 +14136, 65.53571, 117.106 +14137, 66.18274, 115.6559 +14138, 69.41864, 117.3108 +14139, 67.08846, 119.7923 +14140, 65.80637, 134.2886 +14141, 70.23935, 147.1002 +14142, 65.33009, 112.1983 +14143, 65.74455, 121.3022 +14144, 68.90467, 126.1829 +14145, 69.09536, 121.7585 +14146, 68.01171, 130.9674 +14147, 67.90225, 120.5844 +14148, 67.34009, 123.8478 +14149, 66.46165, 108.9752 +14150, 66.75233, 134.2032 +14151, 70.18221, 120.1313 +14152, 66.7024, 122.7568 +14153, 67.3595, 128.4038 +14154, 69.08157, 123.6703 +14155, 70.2507, 132.496 +14156, 69.6539, 138.9897 +14157, 68.02248, 139.3765 +14158, 69.56277, 127.1687 +14159, 68.46777, 137.1892 +14160, 67.83868, 124.7676 +14161, 65.61422, 107.7261 +14162, 69.45527, 139.142 +14163, 66.28291, 126.9862 +14164, 67.56837, 129.8583 +14165, 70.12988, 120.9723 +14166, 68.93421, 124.3325 +14167, 68.81879, 126.6826 +14168, 65.99333, 130.4177 +14169, 66.81007, 127.9307 +14170, 67.94457, 124.4599 +14171, 71.4938, 145.451 +14172, 65.07798, 131.2823 +14173, 69.62029, 137.4994 +14174, 67.5144, 139.3524 +14175, 68.40947, 134.8715 +14176, 66.00603, 110.5781 +14177, 68.33191, 123.6727 +14178, 67.87778, 112.5046 +14179, 68.97539, 119.726 +14180, 68.35379, 130.8928 +14181, 67.18885, 139.5173 +14182, 64.66663, 125.7713 +14183, 70.8471, 141.3167 +14184, 65.85219, 123.4676 +14185, 65.77447, 117.2936 +14186, 67.52969, 133.6229 +14187, 67.40883, 137.1679 +14188, 66.12206, 126.2247 +14189, 67.61112, 133.3822 +14190, 65.59254, 128.3061 +14191, 66.38916, 121.0049 +14192, 68.18774, 121.2644 +14193, 66.10402, 112.9015 +14194, 67.64821, 122.4457 +14195, 66.43868, 125.0148 +14196, 63.50433, 117.6413 +14197, 67.40581, 140.1673 +14198, 68.88553, 144.6597 +14199, 64.19132, 109.6336 +14200, 64.87451, 124.6717 +14201, 67.55913, 128.8533 +14202, 71.62407, 143.172 +14203, 67.8134, 121.2207 +14204, 67.20623, 127.9349 +14205, 67.80392, 114.6993 +14206, 67.19869, 130.2931 +14207, 67.85377, 109.7363 +14208, 66.70262, 128.6075 +14209, 72.60211, 142.884 +14210, 68.85807, 120.9967 +14211, 69.56765, 121.9698 +14212, 66.10458, 120.3264 +14213, 67.18371, 132.8096 +14214, 71.11644, 128.7753 +14215, 70.62083, 144.7966 +14216, 66.12419, 120.1358 +14217, 68.95687, 150.6544 +14218, 65.39463, 119.9506 +14219, 70.83034, 134.1303 +14220, 68.86758, 132.4712 +14221, 68.49492, 132.0698 +14222, 72.26615, 149.0804 +14223, 65.71143, 105.5179 +14224, 67.46158, 105.7427 +14225, 68.12008, 114.3532 +14226, 69.77291, 140.5532 +14227, 67.17396, 104.8758 +14228, 69.58187, 149.3951 +14229, 64.85647, 112.4751 +14230, 66.92813, 113.5514 +14231, 66.84465, 116.7548 +14232, 66.43222, 115.7098 +14233, 70.39773, 142.9501 +14234, 69.64527, 112.6102 +14235, 67.05199, 112.1167 +14236, 66.43058, 144.3144 +14237, 67.29006, 127.7941 +14238, 67.97572, 123.5864 +14239, 68.42735, 105.5294 +14240, 66.59713, 131.487 +14241, 68.31497, 130.6901 +14242, 64.94728, 106.985 +14243, 68.8079, 138.3584 +14244, 71.29561, 144.5436 +14245, 66.60855, 110.2896 +14246, 71.44829, 138.6818 +14247, 69.38522, 126.5717 +14248, 69.28534, 138.3463 +14249, 67.09518, 104.3434 +14250, 66.14266, 127.4558 +14251, 65.73548, 122.9376 +14252, 68.80922, 119.2303 +14253, 66.25755, 123.4953 +14254, 67.38101, 118.9634 +14255, 65.25753, 123.4155 +14256, 67.71714, 114.8697 +14257, 65.88163, 125.7726 +14258, 65.66446, 123.9655 +14259, 66.97416, 129.4752 +14260, 68.27905, 114.2066 +14261, 66.07261, 114.2463 +14262, 67.56389, 110.8099 +14263, 67.94376, 116.0348 +14264, 64.40307, 105.3112 +14265, 69.2191, 123.4273 +14266, 67.70481, 140.9132 +14267, 65.15201, 129.0039 +14268, 67.30379, 135.3481 +14269, 66.98384, 114.4659 +14270, 68.08508, 109.06 +14271, 64.70474, 122.3172 +14272, 66.42674, 122.363 +14273, 66.91386, 125.1168 +14274, 67.22538, 114.5379 +14275, 70.21976, 134.8329 +14276, 71.3139, 132.3451 +14277, 65.53063, 116.6307 +14278, 69.46173, 134.8631 +14279, 66.22806, 118.1414 +14280, 70.16115, 124.8956 +14281, 68.41222, 135.25 +14282, 69.82319, 148.0173 +14283, 67.17432, 120.4157 +14284, 69.29115, 129.6002 +14285, 67.82581, 130.5398 +14286, 66.40623, 132.3121 +14287, 67.73226, 124.3289 +14288, 69.2642, 139.6425 +14289, 69.89742, 126.3862 +14290, 69.27103, 112.6904 +14291, 70.4306, 118.9721 +14292, 64.2193, 110.3825 +14293, 66.07677, 121.521 +14294, 68.1361, 124.7791 +14295, 64.23356, 105.3489 +14296, 65.91925, 119.0062 +14297, 69.39355, 138.3937 +14298, 67.73392, 125.8656 +14299, 69.48989, 129.9777 +14300, 67.33814, 132.0128 +14301, 66.07833, 126.8215 +14302, 65.98334, 117.0051 +14303, 66.44921, 124.4335 +14304, 69.69715, 147.0065 +14305, 67.12772, 133.4775 +14306, 66.57638, 129.6103 +14307, 68.47646, 159.4214 +14308, 66.73179, 124.7975 +14309, 69.19577, 145.742 +14310, 68.83063, 124.7159 +14311, 67.66406, 123.54 +14312, 65.43432, 124.2937 +14313, 66.14658, 113.9478 +14314, 67.8811, 128.1522 +14315, 68.13498, 119.9046 +14316, 67.73894, 135.291 +14317, 65.59068, 141.912 +14318, 67.95201, 133.4959 +14319, 69.19122, 135.3263 +14320, 69.51645, 140.1555 +14321, 68.74287, 121.1786 +14322, 66.52495, 123.7826 +14323, 69.12783, 145.0336 +14324, 67.94469, 126.01 +14325, 66.97412, 114.544 +14326, 68.3347, 118.5872 +14327, 67.80615, 125.4137 +14328, 68.84585, 118.6805 +14329, 66.41209, 123.1756 +14330, 70.29823, 112.5476 +14331, 69.26533, 146.1078 +14332, 66.6775, 112.6632 +14333, 67.20009, 134.6615 +14334, 66.72465, 123.5835 +14335, 68.44557, 117.5098 +14336, 68.83239, 124.6579 +14337, 69.08936, 140.3997 +14338, 67.16286, 116.5837 +14339, 67.39555, 132.9801 +14340, 66.28334, 116.9799 +14341, 68.24699, 117.2319 +14342, 64.78907, 113.6457 +14343, 64.50572, 106.108 +14344, 70.29401, 136.8676 +14345, 65.22177, 110.3999 +14346, 65.86641, 123.509 +14347, 66.10418, 99.16114 +14348, 68.80487, 119.6668 +14349, 69.24299, 131.5827 +14350, 66.09521, 110.0727 +14351, 71.18037, 150.4801 +14352, 68.1098, 124.4662 +14353, 68.53379, 134.3146 +14354, 63.70189, 109.2781 +14355, 66.46061, 122.5196 +14356, 68.8741, 127.0227 +14357, 66.09188, 142.6998 +14358, 65.6822, 134.6381 +14359, 68.95243, 126.922 +14360, 67.89356, 122.4413 +14361, 64.73622, 110.5326 +14362, 68.01956, 107.7515 +14363, 69.49761, 128.5874 +14364, 65.30787, 115.544 +14365, 70.31537, 115.9457 +14366, 67.79292, 120.1893 +14367, 66.2732, 114.6297 +14368, 68.62718, 152.5129 +14369, 69.24794, 125.3082 +14370, 66.17435, 127.7298 +14371, 68.1089, 100.4395 +14372, 68.11469, 101.8313 +14373, 70.97341, 139.3387 +14374, 69.87424, 132.6157 +14375, 71.52707, 147.3411 +14376, 68.44659, 129.7181 +14377, 66.41665, 144.0879 +14378, 67.10768, 120.6801 +14379, 69.32189, 138.5631 +14380, 68.39004, 118.9528 +14381, 65.45785, 129.6689 +14382, 72.09267, 137.1995 +14383, 67.60688, 133.6038 +14384, 66.92747, 122.0855 +14385, 70.1229, 116.8609 +14386, 69.09843, 127.5529 +14387, 67.41743, 122.343 +14388, 69.45134, 128.3776 +14389, 66.41985, 105.8868 +14390, 65.69863, 114.4188 +14391, 65.31739, 130.3437 +14392, 64.80359, 122.8058 +14393, 68.13705, 133.896 +14394, 70.08693, 130.9994 +14395, 64.03691, 107.6519 +14396, 67.33761, 118.6397 +14397, 71.8434, 136.2137 +14398, 69.1154, 118.8989 +14399, 65.39821, 90.24255 +14400, 65.70757, 135.8894 +14401, 69.66027, 116.0218 +14402, 68.84382, 133.186 +14403, 65.39271, 101.6976 +14404, 70.31722, 134.6496 +14405, 69.19909, 136.7189 +14406, 66.2882, 100.3062 +14407, 66.12228, 119.4939 +14408, 68.15336, 121.0773 +14409, 67.44349, 122.0805 +14410, 66.41455, 112.3032 +14411, 65.35315, 103.4902 +14412, 69.30321, 137.4465 +14413, 67.12751, 150.4042 +14414, 69.30029, 139.6598 +14415, 69.11462, 123.185 +14416, 69.26369, 129.9973 +14417, 66.93177, 107.3342 +14418, 70.80801, 126.0434 +14419, 66.77406, 135.7989 +14420, 65.86587, 126.4569 +14421, 66.72211, 121.3037 +14422, 64.44234, 116.1346 +14423, 69.67413, 135.2951 +14424, 64.92037, 107.1751 +14425, 67.63239, 133.8608 +14426, 68.70454, 137.8656 +14427, 68.82445, 111.7483 +14428, 68.93421, 113.9161 +14429, 70.01339, 139.3902 +14430, 71.44878, 119.4079 +14431, 66.91364, 126.6312 +14432, 68.4292, 122.169 +14433, 68.45391, 113.4185 +14434, 65.33618, 119.0882 +14435, 71.88803, 147.8657 +14436, 68.62216, 135.2735 +14437, 68.10589, 115.1755 +14438, 65.49264, 129.8366 +14439, 66.33612, 125.7748 +14440, 69.07199, 143.9889 +14441, 68.76917, 131.4778 +14442, 68.89473, 133.2498 +14443, 68.77062, 142.0926 +14444, 68.33215, 125.3459 +14445, 67.72393, 134.167 +14446, 65.49304, 103.0317 +14447, 71.06055, 138.7811 +14448, 69.50278, 120.9324 +14449, 68.61663, 125.2735 +14450, 68.54709, 133.5241 +14451, 69.26721, 157.2972 +14452, 70.14424, 119.6536 +14453, 65.9849, 140.6229 +14454, 66.281, 108.7205 +14455, 65.7289, 126.3947 +14456, 70.38391, 142.3535 +14457, 67.47381, 133.874 +14458, 66.16001, 128.3664 +14459, 66.57927, 120.7005 +14460, 69.6185, 134.1051 +14461, 65.77941, 117.2822 +14462, 69.46372, 125.2725 +14463, 63.93234, 99.99409 +14464, 70.09165, 134.6921 +14465, 64.94173, 98.26427 +14466, 68.09547, 109.3772 +14467, 68.83226, 134.4107 +14468, 66.96947, 128.823 +14469, 65.08668, 124.1525 +14470, 69.08362, 131.3282 +14471, 66.0827, 116.0096 +14472, 67.05865, 110.0584 +14473, 68.9081, 108.0602 +14474, 66.81199, 119.9277 +14475, 66.52751, 118.3217 +14476, 67.59674, 125.118 +14477, 68.57752, 127.8544 +14478, 65.15613, 125.1617 +14479, 69.88332, 136.8899 +14480, 67.76589, 131.4036 +14481, 69.48716, 122.6178 +14482, 68.99586, 118.7286 +14483, 71.62687, 154.9613 +14484, 68.30079, 143.765 +14485, 66.99909, 126.4922 +14486, 67.16066, 127.2396 +14487, 68.84511, 118.3629 +14488, 69.77163, 126.8724 +14489, 67.24519, 111.6843 +14490, 67.28553, 133.6576 +14491, 68.62133, 136.9199 +14492, 72.50636, 143.4605 +14493, 71.5681, 124.3189 +14494, 64.55855, 122.9763 +14495, 68.77468, 130.5148 +14496, 65.10069, 104.1238 +14497, 71.21872, 148.4113 +14498, 65.66079, 108.9173 +14499, 64.2657, 116.527 +14500, 68.88757, 107.0324 +14501, 68.44905, 146.4124 +14502, 70.33787, 155.1755 +14503, 71.22339, 140.4949 +14504, 65.94774, 133.6787 +14505, 67.91684, 128.4836 +14506, 65.97902, 129.7483 +14507, 69.27942, 146.3625 +14508, 68.53226, 126.4504 +14509, 71.2069, 123.6671 +14510, 67.2503, 125.7628 +14511, 65.30132, 131.154 +14512, 69.08772, 127.8638 +14513, 66.59265, 124.9371 +14514, 66.49666, 138.0897 +14515, 70.95412, 162.4844 +14516, 65.49834, 121.217 +14517, 69.39388, 124.5431 +14518, 65.27883, 118.9227 +14519, 67.52017, 134.0552 +14520, 68.14598, 111.6476 +14521, 68.81275, 136.0553 +14522, 67.89924, 114.0947 +14523, 69.5175, 136.6971 +14524, 68.07055, 129.4733 +14525, 71.2464, 149.7435 +14526, 68.71642, 121.0296 +14527, 63.99425, 114.3488 +14528, 67.65074, 126.7524 +14529, 66.52185, 133.1447 +14530, 67.39334, 124.7861 +14531, 72.31226, 150.9437 +14532, 68.0661, 104.7306 +14533, 65.20757, 114.5092 +14534, 70.31989, 137.4822 +14535, 66.73391, 126.6537 +14536, 67.2038, 124.1829 +14537, 68.97216, 136.0664 +14538, 67.7248, 132.6022 +14539, 69.56606, 120.6638 +14540, 67.86326, 148.5846 +14541, 69.23555, 130.78 +14542, 63.85084, 121.5242 +14543, 69.77742, 142.0076 +14544, 67.25759, 133.6365 +14545, 64.55164, 116.6069 +14546, 65.91736, 127.4018 +14547, 66.34956, 137.8456 +14548, 62.92407, 121.7441 +14549, 67.15032, 127.7838 +14550, 65.46455, 131.0676 +14551, 70.09519, 142.3265 +14552, 68.66443, 146.0821 +14553, 64.54016, 110.5523 +14554, 66.50297, 122.3483 +14555, 70.7413, 140.665 +14556, 67.63475, 118.3144 +14557, 65.29548, 102.0506 +14558, 67.6782, 136.8665 +14559, 68.11521, 131.2592 +14560, 66.43231, 109.4461 +14561, 67.45289, 135.255 +14562, 67.88061, 127.982 +14563, 65.27546, 127.3989 +14564, 71.80443, 142.3012 +14565, 68.32755, 119.5403 +14566, 68.86515, 115.9509 +14567, 67.11834, 110.0601 +14568, 66.53695, 122.495 +14569, 67.1505, 110.2815 +14570, 68.68724, 130.5799 +14571, 68.22897, 136.0111 +14572, 65.42104, 132.8507 +14573, 67.63027, 126.2376 +14574, 66.9449, 129.0043 +14575, 67.98826, 127.4057 +14576, 69.67882, 139.1821 +14577, 66.46151, 120.111 +14578, 66.54514, 126.768 +14579, 69.65715, 133.1626 +14580, 67.36842, 114.6626 +14581, 67.21698, 125.2345 +14582, 69.12349, 135.3012 +14583, 67.93756, 115.0436 +14584, 68.46766, 116.7778 +14585, 70.4462, 111.9601 +14586, 67.64692, 125.7248 +14587, 67.07315, 140.2758 +14588, 65.37352, 99.56696 +14589, 65.3428, 116.0859 +14590, 69.51448, 131.435 +14591, 69.33945, 126.1415 +14592, 66.86743, 124.1513 +14593, 65.10865, 126.4611 +14594, 72.1849, 144.6639 +14595, 69.02571, 141.4309 +14596, 65.04762, 112.8743 +14597, 69.27824, 148.6852 +14598, 69.11397, 136.755 +14599, 65.39362, 126.2681 +14600, 64.92242, 103.2442 +14601, 68.01742, 124.8878 +14602, 66.84525, 117.8475 +14603, 66.5209, 115.0964 +14604, 67.07104, 124.4466 +14605, 66.20762, 123.8278 +14606, 68.65422, 131.0723 +14607, 67.81484, 130.5051 +14608, 67.97735, 137.2246 +14609, 64.20041, 105.6563 +14610, 71.04071, 127.05 +14611, 71.69734, 131.2912 +14612, 67.752, 115.235 +14613, 69.64704, 149.9833 +14614, 69.3531, 128.1011 +14615, 68.69464, 136.1453 +14616, 67.23085, 122.6459 +14617, 69.33763, 124.0222 +14618, 65.86675, 128.6403 +14619, 68.70414, 130.2447 +14620, 68.64444, 118.1935 +14621, 68.6705, 118.7838 +14622, 66.83271, 134.949 +14623, 68.69297, 143.3212 +14624, 66.51348, 117.2734 +14625, 68.28119, 132.4379 +14626, 69.39405, 123.72 +14627, 67.3979, 129.8379 +14628, 72.86535, 125.1006 +14629, 67.52936, 138.9031 +14630, 64.60023, 106.0584 +14631, 69.98289, 134.2094 +14632, 70.333, 127.7615 +14633, 64.3196, 115.4439 +14634, 67.49125, 113.672 +14635, 67.80629, 118.8678 +14636, 65.30266, 104.9205 +14637, 70.81212, 133.9088 +14638, 68.19915, 117.0917 +14639, 69.13698, 140.5356 +14640, 66.59934, 144.2746 +14641, 70.58075, 131.9826 +14642, 66.90518, 105.7686 +14643, 66.74813, 115.058 +14644, 66.83292, 119.15 +14645, 69.35713, 151.3173 +14646, 68.63272, 128.2595 +14647, 69.12693, 125.7313 +14648, 67.0631, 128.2475 +14649, 67.46642, 124.2242 +14650, 66.60284, 131.8328 +14651, 70.1147, 135.0549 +14652, 70.12917, 131.9033 +14653, 68.76147, 131.2722 +14654, 70.05388, 150.4834 +14655, 68.16839, 122.3354 +14656, 67.51951, 119.7932 +14657, 68.27418, 132.6718 +14658, 67.30217, 113.9822 +14659, 66.31157, 128.2458 +14660, 70.05639, 121.4094 +14661, 70.24768, 140.4239 +14662, 69.86768, 123.2387 +14663, 68.9313, 112.5828 +14664, 67.73389, 134.9801 +14665, 67.93682, 113.7462 +14666, 67.92146, 130.6895 +14667, 70.4633, 118.4807 +14668, 68.16156, 131.5248 +14669, 68.81242, 144.2511 +14670, 70.05484, 125.4148 +14671, 65.61528, 111.0683 +14672, 70.77456, 124.4918 +14673, 68.13409, 134.5848 +14674, 68.87718, 135.3765 +14675, 66.85615, 114.1814 +14676, 65.19143, 115.6044 +14677, 69.53261, 134.0578 +14678, 71.28136, 135.9541 +14679, 66.47317, 106.9388 +14680, 69.85972, 137.5864 +14681, 66.56784, 120.5673 +14682, 64.99896, 121.0243 +14683, 65.5967, 131.1701 +14684, 65.11179, 119.3086 +14685, 72.43607, 137.4056 +14686, 66.27465, 129.0097 +14687, 67.6844, 118.539 +14688, 64.94671, 129.5048 +14689, 66.09981, 117.7368 +14690, 66.84125, 114.8767 +14691, 67.23393, 127.1033 +14692, 67.9501, 110.3671 +14693, 66.34338, 130.6015 +14694, 71.54739, 152.425 +14695, 71.10011, 133.8311 +14696, 66.80152, 124.965 +14697, 71.09075, 120.9877 +14698, 67.42631, 131.6672 +14699, 68.87576, 135.248 +14700, 67.6317, 118.7798 +14701, 65.61406, 138.9284 +14702, 67.09963, 113.8329 +14703, 68.15761, 119.3325 +14704, 67.06521, 104.9855 +14705, 67.00626, 138.5947 +14706, 69.21534, 133.6759 +14707, 65.49959, 119.6168 +14708, 67.12282, 131.6157 +14709, 66.27818, 129.3183 +14710, 68.05092, 129.3991 +14711, 71.21378, 150.0079 +14712, 65.8059, 128.0218 +14713, 69.01341, 127.8369 +14714, 64.38771, 103.3323 +14715, 71.28885, 132.8358 +14716, 68.01059, 136.4326 +14717, 67.40277, 131.675 +14718, 65.86277, 122.7182 +14719, 70.04407, 141.6413 +14720, 64.66349, 118.2509 +14721, 66.20468, 129.3437 +14722, 72.42652, 142.1927 +14723, 68.18756, 125.1862 +14724, 65.09832, 134.0936 +14725, 64.94607, 123.7487 +14726, 68.74582, 132.8903 +14727, 67.48779, 124.9625 +14728, 65.11114, 94.45359 +14729, 68.70291, 123.1642 +14730, 64.81203, 122.4859 +14731, 68.35035, 128.6184 +14732, 72.14415, 142.8257 +14733, 68.23639, 147.0343 +14734, 66.90007, 121.555 +14735, 68.96221, 145.2393 +14736, 69.44312, 119.8432 +14737, 65.04087, 131.9553 +14738, 67.33467, 126.2769 +14739, 70.00111, 139.7206 +14740, 65.86413, 114.5532 +14741, 66.76124, 121.4799 +14742, 68.6178, 138.031 +14743, 66.49285, 129.3542 +14744, 68.45981, 119.1174 +14745, 69.6046, 125.9209 +14746, 71.62721, 151.8017 +14747, 66.56949, 100.3424 +14748, 65.36772, 115.6658 +14749, 71.5466, 134.8652 +14750, 67.9212, 121.8751 +14751, 68.53005, 127.0172 +14752, 66.29177, 125.542 +14753, 70.0892, 148.1898 +14754, 66.45724, 137.0889 +14755, 66.90417, 124.4345 +14756, 71.96531, 160.8373 +14757, 65.79737, 111.0351 +14758, 71.99473, 135.4855 +14759, 67.88118, 125.1443 +14760, 67.9713, 132.0724 +14761, 66.68833, 124.6627 +14762, 69.08259, 120.4445 +14763, 67.7725, 120.6289 +14764, 67.54727, 127.846 +14765, 64.64468, 122.7172 +14766, 69.69364, 126.2985 +14767, 68.70439, 134.8945 +14768, 68.16991, 120.5405 +14769, 68.33163, 123.6751 +14770, 65.19663, 120.1252 +14771, 69.12973, 147.2327 +14772, 66.76336, 149.5213 +14773, 66.10726, 114.3077 +14774, 68.69461, 118.3486 +14775, 69.51345, 129.3136 +14776, 67.15638, 116.1097 +14777, 66.52538, 118.2619 +14778, 71.057, 150.4875 +14779, 69.19665, 124.4735 +14780, 66.76492, 120.8445 +14781, 68.09253, 121.9168 +14782, 67.35046, 129.862 +14783, 68.25237, 114.1292 +14784, 67.66866, 121.0367 +14785, 66.21079, 116.8308 +14786, 70.37472, 141.5234 +14787, 67.8132, 118.614 +14788, 66.42694, 115.2073 +14789, 68.20158, 114.2983 +14790, 68.77079, 135.0788 +14791, 70.60585, 124.6664 +14792, 68.09479, 129.3895 +14793, 64.8915, 121.5407 +14794, 67.12568, 137.1491 +14795, 69.97844, 129.5848 +14796, 67.77866, 130.9258 +14797, 71.39205, 144.5625 +14798, 67.96867, 144.8993 +14799, 72.76728, 158.5479 +14800, 73.38719, 154.6609 +14801, 69.32501, 135.3784 +14802, 66.65826, 124.0843 +14803, 68.63739, 137.5213 +14804, 70.10928, 126.2247 +14805, 68.39804, 141.12 +14806, 72.29783, 123.4305 +14807, 70.62523, 136.39 +14808, 71.44332, 141.1457 +14809, 70.41386, 133.5107 +14810, 64.86518, 114.7467 +14811, 68.80394, 111.0717 +14812, 69.49145, 138.1768 +14813, 66.01854, 113.5605 +14814, 70.48654, 127.2451 +14815, 66.80862, 125.5152 +14816, 70.6607, 132.6907 +14817, 66.68431, 104.9599 +14818, 65.58814, 132.2702 +14819, 66.36507, 124.7192 +14820, 67.09404, 97.52424 +14821, 66.48373, 109.9676 +14822, 68.82707, 132.1645 +14823, 64.69002, 114.4221 +14824, 69.01948, 113.5284 +14825, 69.43111, 141.7182 +14826, 70.07435, 133.3257 +14827, 66.8212, 121.7781 +14828, 68.06909, 129.9501 +14829, 69.6444, 124.8979 +14830, 64.80698, 121.6822 +14831, 67.37179, 125.3064 +14832, 67.39488, 108.6014 +14833, 68.39465, 118.6916 +14834, 68.4231, 156.2505 +14835, 69.41607, 124.4915 +14836, 66.82138, 120.3149 +14837, 65.58027, 109.5115 +14838, 71.02776, 160.1136 +14839, 67.8096, 141.57 +14840, 71.01235, 136.6575 +14841, 67.45353, 137.7991 +14842, 69.77346, 143.6829 +14843, 64.07515, 111.1404 +14844, 68.36516, 143.9045 +14845, 69.40935, 119.8486 +14846, 66.43953, 104.0047 +14847, 69.77091, 126.6292 +14848, 71.29182, 148.3832 +14849, 67.26889, 119.2626 +14850, 68.52627, 140.521 +14851, 63.95467, 100.0358 +14852, 68.27822, 114.3188 +14853, 69.01564, 129.8548 +14854, 68.33275, 131.6805 +14855, 65.91471, 111.3135 +14856, 65.5471, 119.9587 +14857, 66.88448, 124.6394 +14858, 67.50342, 116.6803 +14859, 71.35101, 148.2762 +14860, 66.5912, 128.9648 +14861, 65.14281, 105.1575 +14862, 67.26097, 128.2402 +14863, 68.77974, 134.0494 +14864, 66.92786, 125.5997 +14865, 70.20106, 154.8632 +14866, 68.1684, 109.4807 +14867, 65.9685, 121.0642 +14868, 69.2944, 139.0479 +14869, 68.18398, 115.8062 +14870, 67.3956, 138.3648 +14871, 69.32049, 127.5045 +14872, 66.66937, 120.5405 +14873, 68.62135, 145.4409 +14874, 69.82043, 135.6144 +14875, 68.00272, 139.2716 +14876, 69.35468, 129.8923 +14877, 70.19606, 147.7932 +14878, 69.94747, 138.2673 +14879, 69.48896, 117.94 +14880, 70.48888, 119.9716 +14881, 65.70003, 115.1262 +14882, 69.24694, 126.8539 +14883, 67.30239, 133.8636 +14884, 69.64951, 135.6532 +14885, 65.50558, 130.4526 +14886, 72.17516, 134.4131 +14887, 67.65538, 140.6611 +14888, 69.96429, 130.0129 +14889, 66.61309, 124.0167 +14890, 67.43982, 136.3044 +14891, 63.73814, 126.0077 +14892, 68.71436, 134.623 +14893, 70.77193, 133.9877 +14894, 69.37902, 141.4066 +14895, 68.95079, 137.57 +14896, 68.90363, 131.0382 +14897, 65.21203, 116.4051 +14898, 67.31722, 117.2372 +14899, 64.38819, 124.1841 +14900, 66.35807, 119.5823 +14901, 66.38672, 131.7982 +14902, 66.6684, 143.8648 +14903, 65.19706, 95.36862 +14904, 69.42103, 117.8366 +14905, 64.06378, 123.079 +14906, 68.24753, 133.6979 +14907, 68.89321, 133.5338 +14908, 70.65875, 141.7325 +14909, 66.17187, 132.7272 +14910, 69.79746, 139.5868 +14911, 69.39866, 149.026 +14912, 67.93777, 117.9616 +14913, 67.26378, 127.81 +14914, 67.44849, 139.9993 +14915, 68.57844, 127.3023 +14916, 68.18689, 116.6239 +14917, 71.21952, 142.336 +14918, 69.32096, 123.3451 +14919, 65.65913, 110.7946 +14920, 70.37, 143.1529 +14921, 64.79003, 131.5436 +14922, 65.92313, 97.29027 +14923, 66.73192, 128.011 +14924, 65.40144, 111.9967 +14925, 66.71355, 121.5899 +14926, 65.52829, 120.2156 +14927, 68.39107, 127.4346 +14928, 69.32446, 131.3958 +14929, 73.19305, 144.5579 +14930, 68.08406, 116.6268 +14931, 70.00156, 122.5793 +14932, 70.67706, 117.6249 +14933, 66.43552, 134.1497 +14934, 68.10398, 133.4111 +14935, 70.03197, 126.462 +14936, 64.56491, 114.9612 +14937, 68.39336, 132.7568 +14938, 68.0955, 127.074 +14939, 66.25512, 137.4863 +14940, 67.61981, 113.9223 +14941, 67.10991, 130.6669 +14942, 68.30287, 122.2908 +14943, 70.05068, 126.1234 +14944, 67.69089, 132.2541 +14945, 69.26578, 122.9495 +14946, 70.84848, 131.7416 +14947, 67.14127, 133.1617 +14948, 65.6565, 121.3197 +14949, 67.91043, 120.8734 +14950, 66.40429, 130.1516 +14951, 67.17903, 126.7042 +14952, 65.97607, 136.9425 +14953, 66.04298, 114.3685 +14954, 71.71449, 153.2031 +14955, 66.09004, 125.3156 +14956, 68.28237, 137.1149 +14957, 69.2815, 127.2959 +14958, 65.76268, 113.9716 +14959, 66.98438, 122.2353 +14960, 65.6529, 131.5253 +14961, 68.95828, 138.3287 +14962, 68.66489, 119.6475 +14963, 63.28472, 134.2575 +14964, 69.3378, 145.5026 +14965, 68.23957, 129.4421 +14966, 67.91304, 111.7014 +14967, 66.16765, 133.5217 +14968, 67.31495, 115.6811 +14969, 66.97137, 118.4895 +14970, 65.80597, 124.801 +14971, 66.79723, 118.5487 +14972, 65.12057, 115.9726 +14973, 66.84355, 123.2907 +14974, 68.38863, 110.792 +14975, 68.68709, 138.8422 +14976, 71.59953, 129.4179 +14977, 68.32022, 137.7368 +14978, 68.31, 108.7164 +14979, 66.47004, 122.2851 +14980, 68.12458, 130.3549 +14981, 72.0858, 138.3812 +14982, 68.82191, 114.476 +14983, 66.5675, 113.8546 +14984, 70.19345, 131.3116 +14985, 68.39855, 142.0522 +14986, 68.23971, 132.4932 +14987, 71.56445, 137.2813 +14988, 68.85791, 137.9349 +14989, 70.46101, 133.3018 +14990, 68.19618, 119.5517 +14991, 67.34632, 123.2255 +14992, 67.57452, 119.1006 +14993, 70.49071, 137.8164 +14994, 69.00788, 133.1503 +14995, 69.18618, 120.7711 +14996, 69.27963, 134.9563 +14997, 68.30928, 132.4946 +14998, 69.85509, 112.2776 +14999, 66.99205, 154.8623 +15000, 68.83483, 132.5996 +15001, 65.51992, 111.0786 +15002, 69.3211, 128.1426 +15003, 64.91352, 132.2049 +15004, 67.44463, 136.2209 +15005, 68.36722, 135.6455 +15006, 65.47213, 83.33859 +15007, 69.36933, 134.65 +15008, 69.54885, 134.6695 +15009, 65.32827, 114.8547 +15010, 67.09904, 118.2642 +15011, 66.42256, 133.6799 +15012, 71.0263, 128.2917 +15013, 69.2985, 121.2343 +15014, 66.85983, 116.8298 +15015, 65.68344, 116.4899 +15016, 68.44039, 131.2274 +15017, 66.09236, 124.9588 +15018, 66.89796, 105.0615 +15019, 67.65639, 126.238 +15020, 69.01429, 132.3267 +15021, 67.95663, 134.3919 +15022, 62.63031, 98.87507 +15023, 70.47594, 118.9593 +15024, 70.99287, 132.9842 +15025, 68.86312, 137.4119 +15026, 71.61657, 126.9508 +15027, 65.17342, 110.3023 +15028, 66.6864, 134.4681 +15029, 68.20849, 133.9785 +15030, 67.12074, 115.4099 +15031, 68.43384, 124.156 +15032, 67.80769, 139.6569 +15033, 69.55436, 126.1296 +15034, 69.626, 130.6209 +15035, 66.73544, 127.3142 +15036, 66.85735, 115.6542 +15037, 68.73859, 114.5677 +15038, 67.84689, 129.8946 +15039, 67.12274, 132.4266 +15040, 65.01406, 124.2521 +15041, 67.47471, 102.7244 +15042, 67.25719, 144.0751 +15043, 67.24826, 127.6367 +15044, 66.30738, 104.6319 +15045, 67.41475, 125.3851 +15046, 66.58363, 126.1534 +15047, 65.93812, 104.2595 +15048, 69.80661, 115.1499 +15049, 68.54967, 139.205 +15050, 70.66876, 133.3968 +15051, 68.59748, 123.4007 +15052, 69.92431, 124.9688 +15053, 69.29221, 140.663 +15054, 70.8323, 114.6896 +15055, 69.47654, 150.3265 +15056, 65.12741, 109.1273 +15057, 66.52541, 100.9191 +15058, 66.75392, 109.0707 +15059, 67.60759, 132.4966 +15060, 70.49105, 131.9175 +15061, 62.95883, 122.8187 +15062, 67.16728, 126.6304 +15063, 67.37938, 115.0117 +15064, 66.73605, 120.1152 +15065, 66.50685, 120.364 +15066, 66.30539, 103.8522 +15067, 69.84097, 139.6097 +15068, 68.43171, 111.0371 +15069, 70.21848, 113.2947 +15070, 67.94852, 118.2123 +15071, 67.36696, 118.6315 +15072, 69.06908, 146.7647 +15073, 64.44615, 113.4007 +15074, 65.42316, 122.9447 +15075, 66.9796, 129.0708 +15076, 69.01274, 116.1521 +15077, 67.59833, 136.7678 +15078, 65.9525, 130.6652 +15079, 67.12379, 125.5072 +15080, 70.19532, 126.5499 +15081, 69.38455, 131.5782 +15082, 69.88289, 143.9437 +15083, 66.33476, 124.6417 +15084, 69.86933, 127.138 +15085, 69.17547, 142.2736 +15086, 63.69076, 100.3788 +15087, 68.94349, 112.6258 +15088, 67.82915, 103.9962 +15089, 68.71299, 133.2248 +15090, 71.78816, 143.102 +15091, 70.80693, 142.3487 +15092, 67.04918, 116.1558 +15093, 70.7374, 143.0558 +15094, 63.99731, 102.6267 +15095, 68.44638, 132.1454 +15096, 64.8252, 117.1635 +15097, 70.32462, 131.8657 +15098, 70.20879, 163.8728 +15099, 68.04153, 137.4699 +15100, 68.99917, 129.7717 +15101, 67.06517, 120.3846 +15102, 69.51164, 124.2078 +15103, 63.43652, 126.3691 +15104, 70.20568, 136.4101 +15105, 67.06886, 127.1024 +15106, 70.71333, 141.4736 +15107, 66.53558, 133.3857 +15108, 66.33691, 123.5988 +15109, 66.76051, 131.4503 +15110, 69.23838, 126.2803 +15111, 64.43238, 92.31443 +15112, 67.65387, 114.1495 +15113, 65.28297, 121.8429 +15114, 67.29254, 122.4833 +15115, 66.67426, 108.0738 +15116, 67.18934, 126.9589 +15117, 68.86103, 148.8058 +15118, 65.91764, 136.8749 +15119, 67.48274, 137.6678 +15120, 65.86101, 123.4096 +15121, 69.58332, 131.3107 +15122, 66.48236, 121.0822 +15123, 67.12587, 130.7108 +15124, 68.03928, 118.5115 +15125, 70.60422, 133.7741 +15126, 67.35277, 134.1125 +15127, 64.96602, 124.6932 +15128, 69.73659, 126.8534 +15129, 67.85001, 116.5084 +15130, 67.11269, 137.5854 +15131, 68.91724, 126.4464 +15132, 66.10288, 143.3539 +15133, 66.92685, 114.6862 +15134, 67.62461, 123.238 +15135, 67.68375, 146.636 +15136, 69.69504, 131.1339 +15137, 67.53015, 109.7927 +15138, 66.49217, 112.7151 +15139, 67.49556, 115.8608 +15140, 65.22979, 118.5155 +15141, 65.14555, 109.0792 +15142, 69.96429, 118.1581 +15143, 66.96921, 119.725 +15144, 72.68406, 140.7454 +15145, 70.62989, 143.2336 +15146, 66.28962, 127.5244 +15147, 66.87942, 118.188 +15148, 69.63736, 138.7506 +15149, 72.13221, 133.896 +15150, 67.64678, 116.0453 +15151, 66.29793, 130.1744 +15152, 66.24001, 114.7215 +15153, 69.04627, 123.7546 +15154, 68.95959, 124.4974 +15155, 67.50624, 145.7484 +15156, 67.53604, 137.2567 +15157, 68.20346, 121.3491 +15158, 67.12901, 119.374 +15159, 67.57283, 123.2969 +15160, 66.67624, 140.9397 +15161, 65.26043, 101.1571 +15162, 69.96595, 142.8463 +15163, 69.89433, 130.4151 +15164, 69.40222, 126.5053 +15165, 69.38557, 139.4706 +15166, 68.37978, 126.2987 +15167, 69.18198, 139.8423 +15168, 71.88614, 134.319 +15169, 69.07546, 114.2239 +15170, 66.55796, 117.9522 +15171, 65.84951, 135.0075 +15172, 69.30328, 128.4679 +15173, 70.56769, 137.2495 +15174, 65.70932, 124.1531 +15175, 68.28887, 129.7135 +15176, 68.64234, 126.0445 +15177, 66.48124, 124.1437 +15178, 66.33382, 128.3406 +15179, 67.14291, 110.4774 +15180, 68.01799, 131.4676 +15181, 67.99908, 132.4317 +15182, 66.54521, 125.3635 +15183, 66.48652, 133.496 +15184, 68.49951, 106.7804 +15185, 67.05746, 140.4379 +15186, 67.81343, 122.49 +15187, 70.76865, 141.9201 +15188, 67.35674, 119.6444 +15189, 66.58169, 140.4575 +15190, 68.81841, 115.7801 +15191, 67.78353, 138.1807 +15192, 70.59967, 133.0057 +15193, 66.17798, 117.8164 +15194, 64.52454, 122.6902 +15195, 69.19398, 124.8873 +15196, 72.00347, 115.7439 +15197, 68.22649, 135.6941 +15198, 64.9649, 110.6567 +15199, 68.72693, 140.5141 +15200, 65.62412, 102.6406 +15201, 67.93149, 119.2796 +15202, 68.15359, 136.3666 +15203, 67.10444, 119.5672 +15204, 66.78636, 115.2495 +15205, 67.47237, 119.3153 +15206, 69.15877, 134.0016 +15207, 66.94609, 124.1271 +15208, 64.64516, 121.6082 +15209, 68.23103, 119.5605 +15210, 74.59993, 147.0372 +15211, 69.17074, 116.6371 +15212, 64.4579, 106.3788 +15213, 67.89229, 136.952 +15214, 67.93228, 139.162 +15215, 65.63166, 124.0105 +15216, 69.93332, 151.8863 +15217, 67.06235, 119.6547 +15218, 68.72155, 134.1575 +15219, 67.99221, 120.0651 +15220, 69.48024, 131.2464 +15221, 69.63642, 134.5954 +15222, 68.6781, 113.8461 +15223, 68.93508, 135.1919 +15224, 65.25731, 113.4053 +15225, 69.55037, 150.3096 +15226, 64.50942, 126.2417 +15227, 66.76791, 105.8579 +15228, 68.19097, 119.0327 +15229, 71.36573, 149.988 +15230, 71.51642, 134.707 +15231, 70.1695, 143.5692 +15232, 67.27132, 113.8254 +15233, 63.92789, 122.9493 +15234, 70.109, 114.8256 +15235, 70.32118, 130.2398 +15236, 68.62967, 125.1725 +15237, 64.68249, 116.3063 +15238, 65.62406, 127.038 +15239, 68.33608, 130.0088 +15240, 68.15973, 128.8837 +15241, 66.39703, 129.2909 +15242, 68.7637, 133.8946 +15243, 62.73218, 115.6746 +15244, 67.25989, 119.323 +15245, 67.31674, 127.174 +15246, 70.01359, 144.3033 +15247, 66.29943, 123.5503 +15248, 69.3621, 134.9359 +15249, 67.36081, 126.2309 +15250, 66.67762, 117.7297 +15251, 67.48578, 118.3315 +15252, 69.01325, 126.9036 +15253, 68.93436, 113.2651 +15254, 67.98407, 142.2802 +15255, 64.70492, 113.5925 +15256, 68.71176, 142.4521 +15257, 66.65959, 121.0303 +15258, 67.62403, 118.5923 +15259, 69.56171, 137.7018 +15260, 66.20244, 118.5927 +15261, 69.69845, 133.8294 +15262, 64.18408, 128.3516 +15263, 67.04695, 116.5957 +15264, 65.07655, 112.7787 +15265, 66.54927, 119.9512 +15266, 64.94199, 118.4685 +15267, 70.72113, 138.7877 +15268, 65.72731, 105.9051 +15269, 70.72856, 132.1233 +15270, 69.73747, 142.4348 +15271, 70.38866, 118.807 +15272, 66.2377, 127.8696 +15273, 69.15005, 119.5495 +15274, 71.55308, 143.2831 +15275, 67.3427, 120.6477 +15276, 70.81002, 147.7208 +15277, 68.94879, 134.6874 +15278, 67.83322, 107.5648 +15279, 66.80215, 115.2344 +15280, 62.38539, 105.2355 +15281, 70.19469, 134.5963 +15282, 68.78438, 134.1788 +15283, 69.24853, 109.9131 +15284, 70.30374, 125.2977 +15285, 70.82191, 129.2991 +15286, 71.00821, 146.8951 +15287, 68.13521, 130.0498 +15288, 69.55141, 125.0764 +15289, 66.80746, 99.00428 +15290, 64.38131, 117.1049 +15291, 68.01762, 114.3042 +15292, 69.57085, 124.6849 +15293, 67.64249, 131.7347 +15294, 67.09186, 115.918 +15295, 71.33608, 136.9999 +15296, 68.33188, 134.8577 +15297, 68.19698, 141.5204 +15298, 71.61186, 138.5029 +15299, 68.58219, 125.3785 +15300, 69.51224, 127.0237 +15301, 68.94224, 121.7044 +15302, 67.56831, 130.4685 +15303, 62.70761, 121.0772 +15304, 69.65338, 144.7186 +15305, 69.17779, 123.8314 +15306, 69.1034, 128.4483 +15307, 66.22062, 142.7467 +15308, 63.90675, 120.7712 +15309, 68.0134, 142.6934 +15310, 67.39766, 124.2776 +15311, 67.86913, 123.3232 +15312, 68.93266, 109.3652 +15313, 64.65561, 129.5612 +15314, 67.64286, 116.2336 +15315, 68.5499, 144.1276 +15316, 66.47408, 122.8267 +15317, 65.95487, 112.2416 +15318, 66.32695, 113.5088 +15319, 68.26741, 123.2998 +15320, 70.78463, 134.7647 +15321, 70.4697, 139.8125 +15322, 64.96269, 122.9922 +15323, 68.34706, 130.6799 +15324, 73.07882, 147.7522 +15325, 70.32529, 134.3631 +15326, 72.11328, 143.5666 +15327, 72.90519, 139.1213 +15328, 64.87304, 118.9879 +15329, 68.88989, 123.4282 +15330, 69.17388, 122.9818 +15331, 66.71493, 123.5503 +15332, 67.02678, 140.1351 +15333, 67.30884, 118.4517 +15334, 62.58703, 102.193 +15335, 68.64869, 129.519 +15336, 67.74901, 120.7554 +15337, 71.64536, 122.4384 +15338, 66.66707, 121.7723 +15339, 68.299, 127.1307 +15340, 67.18546, 119.8945 +15341, 67.60484, 145.6195 +15342, 67.42626, 110.1731 +15343, 66.47848, 117.1419 +15344, 70.4336, 135.951 +15345, 66.14942, 114.8362 +15346, 65.24499, 133.7044 +15347, 68.29032, 124.673 +15348, 68.78918, 132.8131 +15349, 69.25119, 130.8556 +15350, 67.81337, 131.5901 +15351, 67.14685, 129.0973 +15352, 66.38206, 119.9348 +15353, 69.90033, 135.8803 +15354, 69.87924, 147.5404 +15355, 67.05535, 123.0133 +15356, 69.92107, 150.7238 +15357, 66.75984, 108.9817 +15358, 66.63653, 106.6289 +15359, 68.95163, 126.1426 +15360, 70.80464, 141.4493 +15361, 70.82565, 142.3535 +15362, 65.81239, 142.3511 +15363, 68.58827, 121.4297 +15364, 69.97348, 121.2647 +15365, 65.8631, 120.7951 +15366, 67.18395, 137.6251 +15367, 65.3295, 112.2046 +15368, 70.54919, 143.444 +15369, 64.27425, 115.4872 +15370, 70.23423, 129.5721 +15371, 68.52809, 140.6879 +15372, 66.50366, 132.8973 +15373, 66.6848, 109.0765 +15374, 68.96487, 122.8685 +15375, 65.95854, 122.3757 +15376, 71.1723, 127.8293 +15377, 70.53792, 125.9055 +15378, 68.59623, 121.8365 +15379, 63.09214, 105.3814 +15380, 70.15201, 128.9654 +15381, 69.93896, 135.1878 +15382, 68.3899, 150.545 +15383, 66.77273, 118.2023 +15384, 68.0307, 112.1099 +15385, 68.32284, 117.0799 +15386, 68.70199, 135.324 +15387, 69.18134, 134.7164 +15388, 70.76125, 131.4654 +15389, 67.4487, 138.5211 +15390, 65.80367, 112.9028 +15391, 67.84868, 135.7776 +15392, 70.37215, 117.2445 +15393, 68.05707, 115.4099 +15394, 67.83306, 122.5637 +15395, 68.36174, 128.5694 +15396, 67.68101, 117.5547 +15397, 65.56852, 116.2469 +15398, 65.84858, 118.0476 +15399, 67.48284, 113.4292 +15400, 68.15474, 127.9674 +15401, 67.60055, 115.2546 +15402, 66.3466, 136.7939 +15403, 68.00428, 141.7709 +15404, 65.89079, 111.1971 +15405, 69.71858, 129.3685 +15406, 66.92519, 123.8781 +15407, 67.86156, 134.4959 +15408, 72.30671, 145.3807 +15409, 69.04887, 132.7148 +15410, 68.37203, 137.6722 +15411, 69.46166, 129.7161 +15412, 64.55413, 109.6147 +15413, 62.91846, 111.747 +15414, 69.66751, 114.9432 +15415, 68.7226, 114.1321 +15416, 66.99763, 119.7136 +15417, 67.96265, 129.548 +15418, 62.54756, 102.5937 +15419, 67.69388, 115.6799 +15420, 68.17765, 125.0763 +15421, 66.84001, 140.2859 +15422, 70.49117, 127.9204 +15423, 64.38355, 115.77 +15424, 67.4107, 115.8599 +15425, 68.71162, 136.6454 +15426, 69.38429, 112.8169 +15427, 68.19334, 121.7475 +15428, 67.66466, 120.6145 +15429, 68.85946, 136.1552 +15430, 70.88504, 132.1232 +15431, 68.90069, 128.3104 +15432, 69.74202, 148.7868 +15433, 65.32131, 122.75 +15434, 66.05517, 105.019 +15435, 67.46121, 124.1873 +15436, 66.97366, 119.5436 +15437, 71.24954, 125.3502 +15438, 66.25833, 105.2265 +15439, 65.33602, 127.9746 +15440, 67.81863, 124.7162 +15441, 68.88544, 123.1058 +15442, 68.50931, 123.0264 +15443, 68.59759, 132.1907 +15444, 69.57731, 143.1516 +15445, 69.94225, 131.2863 +15446, 68.32527, 127.9279 +15447, 67.709, 137.9562 +15448, 68.14718, 142.613 +15449, 69.38748, 135.7762 +15450, 67.74435, 131.3401 +15451, 70.22145, 133.1431 +15452, 67.57101, 127.27 +15453, 67.8206, 125.5015 +15454, 66.2936, 114.019 +15455, 68.27218, 119.0224 +15456, 67.90289, 140.4732 +15457, 71.51032, 134.635 +15458, 69.78562, 135.451 +15459, 67.5308, 123.7992 +15460, 68.60276, 140.7911 +15461, 72.9157, 137.3991 +15462, 68.39973, 114.1057 +15463, 68.743, 134.3778 +15464, 67.07172, 126.1538 +15465, 66.5829, 115.1352 +15466, 68.20199, 110.4711 +15467, 68.5013, 136.1652 +15468, 67.65171, 137.7229 +15469, 69.73023, 128.6487 +15470, 65.67533, 95.8643 +15471, 68.98154, 147.9151 +15472, 68.41366, 130.7171 +15473, 67.65729, 128.6169 +15474, 70.93404, 135.8496 +15475, 71.4025, 163.3466 +15476, 68.66985, 119.7289 +15477, 67.29176, 131.9414 +15478, 69.39537, 129.0571 +15479, 67.96799, 121.7029 +15480, 66.18912, 112.539 +15481, 69.42809, 133.8009 +15482, 67.49189, 117.2768 +15483, 68.53399, 120.6305 +15484, 69.81642, 119.9056 +15485, 68.63746, 127.091 +15486, 68.8994, 131.4347 +15487, 67.9315, 105.7268 +15488, 71.5028, 119.767 +15489, 67.15119, 127.6184 +15490, 69.00578, 123.6567 +15491, 71.94177, 158.7778 +15492, 64.97172, 133.6738 +15493, 66.55485, 134.9888 +15494, 68.68354, 132.3782 +15495, 68.36506, 124.8407 +15496, 64.1255, 115.6005 +15497, 66.19137, 129.8423 +15498, 64.14117, 121.0525 +15499, 67.96989, 133.8695 +15500, 69.18067, 133.8081 +15501, 69.19612, 119.4294 +15502, 73.29095, 153.6943 +15503, 69.45026, 117.4511 +15504, 70.48029, 146.3542 +15505, 65.61927, 127.5175 +15506, 66.73212, 120.9633 +15507, 66.97858, 135.7225 +15508, 65.35568, 131.9 +15509, 66.13306, 132.2003 +15510, 66.19537, 111.411 +15511, 69.60618, 115.0129 +15512, 64.85576, 131.9602 +15513, 66.14641, 117.3194 +15514, 68.06858, 147.1991 +15515, 68.42537, 139.2146 +15516, 64.72761, 113.471 +15517, 67.12449, 120.4451 +15518, 68.2669, 120.1299 +15519, 64.63001, 130.0922 +15520, 65.93702, 123.0907 +15521, 69.72134, 134.9164 +15522, 67.2083, 115.8391 +15523, 72.91999, 154.2153 +15524, 69.98652, 129.3433 +15525, 67.19622, 109.1018 +15526, 68.80471, 121.8463 +15527, 68.95943, 131.1717 +15528, 70.71013, 107.6082 +15529, 69.31161, 110.585 +15530, 68.37667, 139.5479 +15531, 65.87762, 108.2863 +15532, 67.57576, 137.937 +15533, 69.04748, 120.0193 +15534, 64.96906, 130.7477 +15535, 65.00848, 112.3542 +15536, 69.66271, 112.7833 +15537, 68.36325, 93.56304 +15538, 67.78303, 135.3219 +15539, 68.35589, 130.4797 +15540, 69.08049, 137.2105 +15541, 66.18595, 116.7954 +15542, 69.8707, 127.2318 +15543, 68.14345, 119.3634 +15544, 71.50856, 147.4461 +15545, 67.58713, 152.0826 +15546, 69.32161, 127.0991 +15547, 64.32043, 101.6548 +15548, 70.04715, 129.3431 +15549, 67.95275, 120.5799 +15550, 69.3643, 115.9751 +15551, 65.61191, 115.1222 +15552, 66.45951, 117.4793 +15553, 67.01312, 116.3448 +15554, 67.15306, 133.1964 +15555, 68.38756, 123.0091 +15556, 66.91337, 123.0284 +15557, 69.39488, 125.889 +15558, 67.43209, 136.7256 +15559, 67.25651, 125.2836 +15560, 70.1574, 129.8738 +15561, 68.21801, 145.046 +15562, 66.54598, 131.5953 +15563, 67.91875, 134.6972 +15564, 65.47246, 125.9926 +15565, 68.64399, 123.5308 +15566, 67.54097, 133.869 +15567, 67.67111, 127.5556 +15568, 67.54769, 129.9528 +15569, 68.83269, 116.6869 +15570, 66.9893, 116.2079 +15571, 68.12926, 139.5733 +15572, 67.21663, 117.1835 +15573, 66.64897, 119.2815 +15574, 67.21762, 127.3762 +15575, 66.21812, 121.0712 +15576, 67.3438, 133.4411 +15577, 68.11292, 109.9029 +15578, 69.87913, 127.7891 +15579, 68.21125, 138.5343 +15580, 65.68767, 141.1901 +15581, 65.99233, 113.6949 +15582, 67.60517, 102.2036 +15583, 65.90505, 139.2275 +15584, 70.34152, 127.0828 +15585, 66.07605, 120.0142 +15586, 65.77453, 126.9642 +15587, 65.71341, 112.0802 +15588, 68.57546, 141.1028 +15589, 67.93372, 112.6789 +15590, 67.70726, 136.6165 +15591, 69.36386, 143.3529 +15592, 70.64307, 133.4741 +15593, 69.04345, 143.0016 +15594, 69.57571, 154.5079 +15595, 67.52772, 136.2476 +15596, 66.33405, 120.4514 +15597, 65.23795, 115.1459 +15598, 71.71197, 127.5762 +15599, 66.40209, 110.5565 +15600, 66.41322, 123.2217 +15601, 65.24322, 132.3124 +15602, 69.37652, 144.9025 +15603, 66.97944, 116.5849 +15604, 66.94715, 116.96 +15605, 68.35779, 119.4615 +15606, 67.72118, 116.2328 +15607, 66.6547, 123.8393 +15608, 71.16116, 131.0291 +15609, 69.76995, 132.3991 +15610, 67.08047, 123.6803 +15611, 70.16271, 132.0564 +15612, 67.20725, 125.4732 +15613, 66.441, 109.2837 +15614, 70.43908, 128.0154 +15615, 67.42411, 117.7129 +15616, 67.23794, 115.5231 +15617, 65.54462, 116.0185 +15618, 68.58579, 131.2912 +15619, 71.46377, 140.9955 +15620, 67.02704, 152.026 +15621, 70.74595, 150.4723 +15622, 64.55871, 123.1474 +15623, 66.43466, 128.8558 +15624, 71.88538, 129.4843 +15625, 67.35006, 136.4792 +15626, 67.26021, 123.2473 +15627, 69.42105, 131.1226 +15628, 67.02923, 118.0796 +15629, 70.15598, 143.471 +15630, 68.16962, 123.4292 +15631, 69.33135, 118.6 +15632, 68.82239, 119.6967 +15633, 70.70061, 132.7463 +15634, 63.01405, 116.679 +15635, 70.79121, 129.9765 +15636, 70.10094, 140.6238 +15637, 67.68598, 113.3493 +15638, 70.44934, 130.0917 +15639, 68.47164, 143.6588 +15640, 69.22334, 147.1708 +15641, 69.05267, 126.3728 +15642, 69.22824, 128.1722 +15643, 69.30531, 140.5582 +15644, 67.3569, 114.6302 +15645, 68.14178, 133.9639 +15646, 67.50705, 127.7368 +15647, 68.87072, 139.0535 +15648, 67.27839, 134.3672 +15649, 66.97126, 116.9116 +15650, 67.27037, 121.5396 +15651, 66.01214, 116.2959 +15652, 65.90324, 117.2595 +15653, 65.97601, 115.5695 +15654, 65.01385, 117.3807 +15655, 68.3634, 126.2682 +15656, 66.71134, 130.885 +15657, 70.69657, 120.929 +15658, 70.69145, 134.6101 +15659, 71.82796, 136.3967 +15660, 65.57821, 112.8178 +15661, 67.87092, 141.7216 +15662, 69.38038, 135.5633 +15663, 69.34518, 139.0857 +15664, 67.16737, 134.124 +15665, 68.26749, 122.9496 +15666, 67.82439, 129.221 +15667, 63.97761, 114.6071 +15668, 68.59532, 135.5424 +15669, 65.85937, 131.0302 +15670, 65.73705, 112.9266 +15671, 68.55083, 137.6187 +15672, 66.17839, 125.057 +15673, 63.43905, 103.7247 +15674, 64.61373, 115.6394 +15675, 64.14292, 114.1789 +15676, 64.25756, 122.5431 +15677, 67.52237, 137.2828 +15678, 66.64326, 119.2689 +15679, 68.4414, 129.9912 +15680, 70.65253, 114.6167 +15681, 68.04596, 113.3741 +15682, 68.07645, 115.4976 +15683, 66.06383, 119.0574 +15684, 69.31688, 138.3508 +15685, 68.35005, 130.7714 +15686, 68.11006, 121.5984 +15687, 67.60474, 132.0105 +15688, 65.64374, 111.5052 +15689, 69.18597, 145.8104 +15690, 70.15414, 127.0499 +15691, 68.92615, 117.2627 +15692, 71.21385, 125.7487 +15693, 70.58186, 116.7541 +15694, 69.20943, 126.4311 +15695, 68.11377, 133.0339 +15696, 67.54765, 130.4505 +15697, 65.63714, 130.5983 +15698, 67.39903, 143.0303 +15699, 68.25314, 120.4308 +15700, 67.56373, 130.1949 +15701, 63.40403, 138.8565 +15702, 67.13774, 114.4542 +15703, 66.48756, 135.5376 +15704, 66.61374, 123.9797 +15705, 68.4256, 130.75 +15706, 71.18574, 143.5065 +15707, 67.99548, 104.9198 +15708, 68.42032, 129.021 +15709, 67.75353, 110.3398 +15710, 68.99095, 135.43 +15711, 66.73917, 118.7027 +15712, 73.15071, 147.0571 +15713, 66.71381, 115.7718 +15714, 67.26833, 122.3568 +15715, 69.68744, 146.7596 +15716, 71.24277, 150.5403 +15717, 67.21908, 128.3988 +15718, 67.04756, 129.4247 +15719, 68.03582, 133.8249 +15720, 66.73546, 123.987 +15721, 64.51386, 145.7486 +15722, 68.14688, 109.3535 +15723, 69.3206, 149.6076 +15724, 68.78965, 136.5204 +15725, 68.86876, 136.3434 +15726, 68.21886, 131.5544 +15727, 70.3612, 110.3731 +15728, 65.26249, 108.1267 +15729, 69.42921, 124.1743 +15730, 65.74235, 129.9598 +15731, 63.94659, 130.0202 +15732, 66.16987, 127.7085 +15733, 64.40661, 114.9881 +15734, 67.26361, 111.7895 +15735, 67.44707, 130.3438 +15736, 65.40338, 102.6185 +15737, 70.44362, 129.8482 +15738, 70.22944, 138.4534 +15739, 68.02875, 132.7304 +15740, 66.88354, 116.153 +15741, 68.52738, 108.5851 +15742, 68.12687, 127.3693 +15743, 69.64371, 137.753 +15744, 66.28769, 122.0997 +15745, 67.5751, 129.523 +15746, 68.65998, 123.6958 +15747, 65.92461, 120.7062 +15748, 70.10254, 139.5667 +15749, 66.8777, 132.8097 +15750, 70.26733, 136.3759 +15751, 65.16569, 137.0949 +15752, 67.89454, 133.6111 +15753, 67.6881, 131.3197 +15754, 63.98477, 117.5309 +15755, 73.2731, 120.6557 +15756, 67.38426, 148.594 +15757, 69.40435, 143.1126 +15758, 67.50653, 114.2218 +15759, 68.20742, 126.5535 +15760, 71.0084, 138.5358 +15761, 66.08852, 127.8555 +15762, 67.10118, 116.9214 +15763, 68.0587, 108.7064 +15764, 68.40527, 141.2409 +15765, 68.86958, 126.5546 +15766, 69.42117, 140.9856 +15767, 66.8765, 114.5692 +15768, 67.38679, 145.2286 +15769, 69.73443, 145.9757 +15770, 67.22426, 117.1126 +15771, 67.8476, 128.6058 +15772, 70.25478, 132.2171 +15773, 65.66468, 132.7203 +15774, 65.68942, 120.1367 +15775, 70.35956, 140.5765 +15776, 67.89833, 117.8036 +15777, 71.29145, 133.9801 +15778, 68.07826, 129.8407 +15779, 67.88304, 109.2468 +15780, 65.7471, 129.3293 +15781, 70.82378, 136.3718 +15782, 68.98715, 130.8191 +15783, 68.20438, 123.5732 +15784, 69.0132, 142.563 +15785, 65.20002, 100.3488 +15786, 65.63714, 135.9242 +15787, 69.41814, 121.004 +15788, 69.3546, 135.1652 +15789, 69.87385, 128.9834 +15790, 69.48099, 123.9738 +15791, 63.8773, 111.8653 +15792, 67.05966, 116.0247 +15793, 66.56715, 130.2285 +15794, 67.36107, 116.0479 +15795, 67.11625, 111.0254 +15796, 69.29711, 135.6468 +15797, 69.78731, 133.3097 +15798, 69.29322, 129.2499 +15799, 70.9491, 131.2845 +15800, 66.63025, 129.8742 +15801, 65.36933, 132.5488 +15802, 68.85029, 120.5336 +15803, 67.71967, 123.9878 +15804, 69.43243, 137.2161 +15805, 70.39465, 137.8235 +15806, 68.07996, 128.6478 +15807, 68.71273, 115.1458 +15808, 67.11097, 134.6806 +15809, 65.95239, 131.6371 +15810, 66.32713, 150.0352 +15811, 68.22637, 120.5216 +15812, 70.70513, 143.6464 +15813, 67.97221, 112.9209 +15814, 69.24506, 145.094 +15815, 69.11257, 129.4851 +15816, 64.77694, 114.4425 +15817, 67.58057, 117.4571 +15818, 69.07466, 130.3215 +15819, 70.55491, 145.2355 +15820, 66.22396, 109.8105 +15821, 64.38465, 109.9922 +15822, 69.10443, 130.7489 +15823, 66.15927, 144.2465 +15824, 66.80091, 112.0282 +15825, 68.97519, 128.6123 +15826, 68.97731, 133.5575 +15827, 71.23152, 142.6203 +15828, 68.61435, 140.4561 +15829, 62.37781, 124.7478 +15830, 66.18523, 121.0028 +15831, 68.24677, 133.8376 +15832, 68.39773, 128.4398 +15833, 69.75441, 131.3891 +15834, 67.40124, 110.1077 +15835, 66.15482, 121.3213 +15836, 67.53005, 146.2208 +15837, 67.82452, 132.4239 +15838, 68.04693, 132.7561 +15839, 66.67182, 107.1052 +15840, 66.66155, 127.8097 +15841, 63.09378, 126.804 +15842, 67.74892, 141.0813 +15843, 70.21034, 142.8787 +15844, 64.37686, 105.2929 +15845, 71.11437, 137.9506 +15846, 67.62251, 131.9704 +15847, 67.05012, 124.1539 +15848, 67.02249, 121.239 +15849, 66.0373, 107.355 +15850, 68.17467, 119.334 +15851, 68.12509, 125.4845 +15852, 67.9441, 129.4576 +15853, 65.23296, 134.0644 +15854, 66.99444, 134.4277 +15855, 69.08538, 127.8524 +15856, 68.18635, 121.5633 +15857, 72.32435, 131.5309 +15858, 68.13306, 110.3872 +15859, 66.18912, 112.8697 +15860, 69.37225, 124.8294 +15861, 66.07944, 134.7904 +15862, 66.44596, 118.9311 +15863, 67.61141, 113.2781 +15864, 68.53111, 131.2487 +15865, 68.06372, 123.56 +15866, 68.76919, 136.6776 +15867, 71.16472, 129.4277 +15868, 70.48029, 119.135 +15869, 70.28214, 134.233 +15870, 70.8243, 149.1779 +15871, 66.79418, 137.4535 +15872, 64.55907, 112.1905 +15873, 68.29073, 127.4853 +15874, 67.16584, 110.988 +15875, 68.85305, 131.1517 +15876, 68.67427, 126.2711 +15877, 70.50813, 129.325 +15878, 69.12074, 131.7384 +15879, 69.05772, 142.9574 +15880, 68.48742, 130.3869 +15881, 66.55005, 113.3649 +15882, 66.25859, 125.5129 +15883, 67.67373, 137.0173 +15884, 66.59621, 115.5486 +15885, 68.5454, 122.0308 +15886, 68.01326, 136.465 +15887, 71.39722, 145.4316 +15888, 65.66147, 113.4022 +15889, 69.0446, 121.1875 +15890, 66.10215, 121.1734 +15891, 68.29647, 140.8319 +15892, 68.92003, 137.5018 +15893, 69.63445, 137.2601 +15894, 68.19362, 122.2916 +15895, 67.68318, 110.2839 +15896, 68.81011, 135.7101 +15897, 67.44676, 125.4474 +15898, 67.81835, 114.9293 +15899, 69.42357, 138.1367 +15900, 69.66435, 135.0944 +15901, 70.1609, 118.3303 +15902, 67.91643, 134.0842 +15903, 69.72084, 129.8715 +15904, 66.27692, 123.4119 +15905, 68.83848, 108.7075 +15906, 66.70584, 128.4442 +15907, 69.88419, 146.8151 +15908, 69.77301, 136.3172 +15909, 67.31753, 118.5609 +15910, 70.62492, 136.7641 +15911, 66.38894, 118.7559 +15912, 67.15444, 127.4159 +15913, 68.86083, 121.9486 +15914, 65.47601, 119.0022 +15915, 67.33502, 125.7401 +15916, 68.45368, 113.8913 +15917, 67.32573, 130.848 +15918, 65.63352, 96.94675 +15919, 69.09134, 128.7349 +15920, 66.68162, 123.8286 +15921, 67.27892, 119.8219 +15922, 66.83412, 141.3197 +15923, 64.8425, 104.1389 +15924, 68.13785, 139.2758 +15925, 67.83599, 145.5619 +15926, 68.43267, 128.1718 +15927, 68.44093, 118.326 +15928, 68.90259, 135.902 +15929, 67.65946, 115.9803 +15930, 64.72884, 126.7694 +15931, 65.16943, 107.2528 +15932, 68.30429, 134.5369 +15933, 67.49387, 137.5206 +15934, 67.59123, 124.1155 +15935, 65.05233, 128.8537 +15936, 71.06411, 129.7451 +15937, 66.51821, 107.858 +15938, 68.41937, 122.5515 +15939, 69.47786, 129.6483 +15940, 66.99148, 126.63 +15941, 67.36273, 126.6374 +15942, 67.06229, 126.849 +15943, 65.89625, 136.3139 +15944, 70.22917, 145.3402 +15945, 65.93523, 118.384 +15946, 69.97458, 126.3133 +15947, 66.95063, 125.1891 +15948, 70.3091, 140.2088 +15949, 70.12037, 133.0408 +15950, 65.7668, 126.4413 +15951, 69.57565, 134.8488 +15952, 65.92296, 108.4948 +15953, 70.79414, 130.4189 +15954, 69.44383, 131.4925 +15955, 66.62863, 130.4575 +15956, 67.80396, 139.6093 +15957, 68.95013, 138.8719 +15958, 71.30744, 146.9161 +15959, 67.58884, 134.6915 +15960, 69.10194, 123.2658 +15961, 71.06352, 147.8189 +15962, 69.84568, 115.9428 +15963, 66.83921, 104.2683 +15964, 69.76971, 137.6183 +15965, 67.58215, 139.1822 +15966, 69.18909, 134.7638 +15967, 74.25069, 150.0567 +15968, 69.13383, 135.5109 +15969, 66.30129, 117.319 +15970, 68.25075, 124.1859 +15971, 70.71204, 156.4888 +15972, 65.20837, 110.58 +15973, 63.79465, 122.6602 +15974, 71.69954, 145.9436 +15975, 68.00717, 141.6695 +15976, 67.55854, 132.8552 +15977, 65.6403, 143.5714 +15978, 64.35459, 107.3014 +15979, 69.7329, 136.9779 +15980, 73.36407, 140.0662 +15981, 65.08527, 120.9151 +15982, 67.59317, 122.3761 +15983, 68.82592, 123.6124 +15984, 66.47578, 117.2748 +15985, 68.44873, 125.3048 +15986, 66.23119, 133.229 +15987, 66.32448, 116.0772 +15988, 67.293, 137.0363 +15989, 65.65561, 124.1935 +15990, 66.92149, 109.5993 +15991, 65.07498, 105.2216 +15992, 67.96785, 131.2363 +15993, 66.14877, 120.1462 +15994, 69.45894, 120.3336 +15995, 65.77765, 123.8685 +15996, 65.23996, 116.0991 +15997, 68.39398, 117.3044 +15998, 66.57914, 113.7488 +15999, 67.67032, 113.9851 +16000, 68.46821, 114.5627 +16001, 67.94276, 147.1207 +16002, 68.41071, 114.7406 +16003, 67.81453, 120.7329 +16004, 66.13517, 135.6964 +16005, 68.84075, 128.7526 +16006, 69.82133, 130.4452 +16007, 70.69125, 131.4881 +16008, 69.67354, 127.5423 +16009, 67.11306, 112.9442 +16010, 67.76652, 113.787 +16011, 67.98509, 117.4293 +16012, 66.10635, 119.1248 +16013, 70.25508, 130.6601 +16014, 69.69406, 127.8872 +16015, 70.62853, 154.1866 +16016, 66.46828, 115.0219 +16017, 65.83352, 118.1788 +16018, 69.43541, 133.457 +16019, 67.18957, 126.4289 +16020, 67.85753, 132.5879 +16021, 70.80011, 130.9031 +16022, 68.23846, 111.4887 +16023, 69.24097, 145.3706 +16024, 69.30102, 127.2747 +16025, 69.52276, 130.5737 +16026, 69.22084, 141.1106 +16027, 67.85295, 129.5885 +16028, 65.77801, 128.725 +16029, 66.55636, 124.4 +16030, 65.75154, 134.4078 +16031, 65.79782, 128.8091 +16032, 68.06347, 118.8537 +16033, 68.3986, 102.3968 +16034, 68.21292, 123.15 +16035, 66.66365, 130.5961 +16036, 65.77131, 112.8459 +16037, 64.85413, 117.4122 +16038, 69.30353, 158.2312 +16039, 67.96803, 111.7532 +16040, 68.60519, 137.1098 +16041, 66.8475, 123.4111 +16042, 67.11017, 116.3094 +16043, 69.15094, 129.7406 +16044, 66.13712, 106.6076 +16045, 66.42691, 138.0277 +16046, 70.39729, 118.1795 +16047, 68.66476, 137.9495 +16048, 70.14358, 133.6875 +16049, 66.8426, 130.6206 +16050, 70.37678, 133.2398 +16051, 68.74193, 116.7499 +16052, 65.41171, 110.589 +16053, 71.92922, 135.987 +16054, 69.84558, 130.0924 +16055, 68.54234, 139.991 +16056, 68.97866, 124.9344 +16057, 67.76261, 112.8224 +16058, 66.49068, 124.7065 +16059, 64.95423, 93.85997 +16060, 67.37242, 132.68 +16061, 71.21076, 136.9751 +16062, 69.7826, 130.0858 +16063, 69.90597, 139.7374 +16064, 70.10361, 151.6632 +16065, 68.52806, 128.6134 +16066, 67.44755, 124.6756 +16067, 68.69408, 121.506 +16068, 68.10934, 131.7102 +16069, 67.69214, 116.534 +16070, 67.63227, 116.31 +16071, 64.61927, 121.4863 +16072, 67.29108, 124.9753 +16073, 69.87057, 140.744 +16074, 67.21068, 135.6258 +16075, 67.51395, 106.5245 +16076, 66.91739, 120.4203 +16077, 69.39064, 147.6976 +16078, 68.90895, 136.3169 +16079, 67.95984, 113.1916 +16080, 67.44107, 126.8993 +16081, 68.93723, 131.1289 +16082, 68.20281, 138.466 +16083, 66.81433, 120.1186 +16084, 69.65587, 127.9894 +16085, 69.37795, 136.1519 +16086, 69.82831, 123.4697 +16087, 65.75387, 112.9789 +16088, 65.7493, 123.9453 +16089, 65.71657, 131.5604 +16090, 67.83512, 131.2806 +16091, 69.31119, 135.1037 +16092, 67.7191, 120.699 +16093, 66.34019, 109.6276 +16094, 67.49858, 120.7825 +16095, 67.31243, 126.4223 +16096, 69.86285, 134.3626 +16097, 65.53745, 123.5052 +16098, 64.59321, 115.3473 +16099, 70.94415, 137.818 +16100, 65.10856, 142.4697 +16101, 65.90327, 121.5589 +16102, 68.98332, 130.488 +16103, 71.82366, 157.4164 +16104, 64.24852, 126.0415 +16105, 70.8681, 147.1265 +16106, 66.96278, 135.505 +16107, 66.12878, 129.3979 +16108, 71.94824, 136.8933 +16109, 65.07127, 108.6386 +16110, 69.67868, 126.0584 +16111, 64.74361, 114.9174 +16112, 69.15274, 125.9758 +16113, 67.27984, 109.7412 +16114, 67.47621, 121.506 +16115, 69.72662, 139.0893 +16116, 70.1707, 111.1782 +16117, 66.61857, 128.6381 +16118, 67.53201, 126.1899 +16119, 66.70138, 122.2916 +16120, 67.70153, 133.0479 +16121, 69.13985, 127.8006 +16122, 68.40056, 133.3174 +16123, 67.09034, 116.1753 +16124, 64.56582, 101.6407 +16125, 65.83884, 112.2939 +16126, 67.8546, 120.8841 +16127, 67.56548, 164.5865 +16128, 68.95006, 150.9348 +16129, 66.88926, 127.4484 +16130, 63.7295, 119.2318 +16131, 67.57752, 139.8852 +16132, 69.1283, 117.7473 +16133, 68.01587, 112.7753 +16134, 67.06685, 117.2326 +16135, 70.64588, 108.4964 +16136, 68.04523, 125.317 +16137, 65.18191, 122.3296 +16138, 67.95231, 125.4864 +16139, 69.25011, 141.4465 +16140, 65.96393, 140.1776 +16141, 67.5947, 115.7894 +16142, 71.04171, 124.8506 +16143, 67.77341, 118.673 +16144, 69.13759, 140.5952 +16145, 66.80684, 118.2042 +16146, 74.47517, 130.9092 +16147, 68.0331, 139.2995 +16148, 68.0644, 122.5887 +16149, 70.12434, 135.7782 +16150, 66.81391, 114.3368 +16151, 69.99107, 145.8768 +16152, 68.46712, 123.8385 +16153, 65.36962, 119.4041 +16154, 66.36395, 118.9485 +16155, 65.26932, 120.7947 +16156, 67.70041, 133.7415 +16157, 65.96714, 117.3999 +16158, 66.02222, 135.7149 +16159, 70.2321, 135.7227 +16160, 68.38172, 131.2653 +16161, 69.64098, 145.0634 +16162, 67.28414, 99.15936 +16163, 69.58655, 151.417 +16164, 65.99345, 109.9817 +16165, 65.25013, 125.8024 +16166, 67.79735, 119.3893 +16167, 70.76063, 149.9261 +16168, 66.54695, 107.2944 +16169, 69.24477, 141.3338 +16170, 67.45018, 151.1216 +16171, 68.89261, 136.2221 +16172, 68.01896, 133.4202 +16173, 68.55845, 127.7299 +16174, 67.35986, 117.0648 +16175, 71.41989, 131.9403 +16176, 68.12119, 134.7049 +16177, 63.85395, 117.3799 +16178, 69.21935, 113.3789 +16179, 70.98516, 134.2274 +16180, 67.06622, 112.0892 +16181, 68.33204, 143.2136 +16182, 68.07284, 117.0658 +16183, 64.26234, 117.8436 +16184, 67.0604, 133.9787 +16185, 67.00242, 109.9566 +16186, 66.31913, 122.8827 +16187, 70.46814, 130.5875 +16188, 64.43246, 119.6113 +16189, 68.4489, 132.9983 +16190, 66.65345, 116.5059 +16191, 65.46283, 128.9968 +16192, 67.0748, 131.4424 +16193, 66.19921, 107.072 +16194, 68.7179, 114.1472 +16195, 66.31607, 114.3084 +16196, 66.64692, 120.2193 +16197, 69.25969, 130.928 +16198, 67.45099, 127.3075 +16199, 64.42715, 93.77605 +16200, 65.53849, 142.5842 +16201, 66.89782, 124.9394 +16202, 70.67184, 144.1236 +16203, 67.93222, 132.3346 +16204, 66.92724, 125.4446 +16205, 66.53067, 109.4724 +16206, 69.31518, 120.3775 +16207, 70.82934, 131.3445 +16208, 66.16717, 114.8612 +16209, 69.87971, 117.8718 +16210, 65.03428, 99.61482 +16211, 69.47601, 143.0517 +16212, 67.9457, 118.4858 +16213, 69.66532, 137.5848 +16214, 69.81227, 140.3692 +16215, 64.61603, 113.1176 +16216, 68.70534, 122.9617 +16217, 67.86034, 116.6122 +16218, 64.56665, 109.1744 +16219, 67.55567, 134.4666 +16220, 68.56515, 143.9649 +16221, 66.91835, 129.4116 +16222, 72.41732, 134.7621 +16223, 71.08753, 135.5392 +16224, 63.93158, 106.8868 +16225, 68.00087, 134.7445 +16226, 66.42765, 120.6609 +16227, 68.58748, 124.3152 +16228, 68.73243, 148.0622 +16229, 67.08349, 127.3686 +16230, 69.95792, 126.6491 +16231, 69.72909, 121.2628 +16232, 69.26196, 138.9057 +16233, 66.69, 128.5966 +16234, 70.36077, 142.2321 +16235, 67.46372, 124.3689 +16236, 68.5373, 121.8393 +16237, 67.50827, 122.1101 +16238, 65.75245, 120.3636 +16239, 66.74609, 129.2159 +16240, 72.21651, 139.8698 +16241, 66.94817, 107.6458 +16242, 67.49868, 157.1014 +16243, 68.42975, 147.8209 +16244, 68.52518, 119.6524 +16245, 66.78274, 118.6653 +16246, 64.79988, 121.5981 +16247, 70.23712, 136.9404 +16248, 73.10806, 140.7235 +16249, 66.2469, 112.0223 +16250, 67.16625, 118.2065 +16251, 69.34644, 125.3572 +16252, 64.6456, 121.8469 +16253, 68.87184, 120.4789 +16254, 66.36918, 123.2573 +16255, 71.20713, 119.6618 +16256, 70.73217, 138.1571 +16257, 68.33913, 111.1084 +16258, 67.79893, 137.6869 +16259, 65.85082, 134.2529 +16260, 68.60721, 144.9214 +16261, 68.04752, 121.127 +16262, 67.92398, 140.6038 +16263, 66.91439, 119.9645 +16264, 64.70896, 118.9869 +16265, 70.77016, 120.547 +16266, 67.3468, 121.395 +16267, 64.86953, 109.9266 +16268, 64.19615, 122.1719 +16269, 68.42556, 129.0887 +16270, 67.23216, 127.4021 +16271, 69.29292, 140.8615 +16272, 66.12768, 124.4191 +16273, 67.15976, 135.3002 +16274, 68.92731, 129.8894 +16275, 70.35575, 126.1017 +16276, 66.56554, 131.7885 +16277, 70.41469, 133.3264 +16278, 66.30858, 132.2852 +16279, 64.92028, 123.1736 +16280, 68.38333, 120.7131 +16281, 66.60948, 128.4356 +16282, 67.74654, 132.4136 +16283, 67.76365, 120.8272 +16284, 67.826, 133.2988 +16285, 68.81311, 130.7308 +16286, 69.31322, 137.2461 +16287, 62.99079, 128.0345 +16288, 68.01395, 127.4918 +16289, 67.88325, 128.8534 +16290, 64.34993, 116.5172 +16291, 69.17264, 121.2414 +16292, 65.01635, 112.8708 +16293, 69.49107, 134.9546 +16294, 71.6126, 140.2298 +16295, 68.13264, 120.655 +16296, 71.05107, 146.4425 +16297, 69.16088, 137.6839 +16298, 70.64956, 136.3774 +16299, 68.2516, 122.4347 +16300, 65.20641, 111.7598 +16301, 69.1875, 100.505 +16302, 68.26068, 121.9934 +16303, 69.44096, 127.7445 +16304, 66.8189, 128.3391 +16305, 68.97099, 122.6575 +16306, 70.46407, 136.6546 +16307, 70.04348, 137.2425 +16308, 67.31087, 141.1151 +16309, 69.03446, 119.7233 +16310, 67.49014, 112.3328 +16311, 67.33983, 119.2277 +16312, 72.06505, 133.0291 +16313, 68.44578, 134.0888 +16314, 70.93858, 151.7394 +16315, 65.99061, 100.1656 +16316, 65.69995, 129.2969 +16317, 67.88781, 123.7831 +16318, 68.71714, 130.7432 +16319, 70.58546, 130.0892 +16320, 70.50692, 132.8177 +16321, 64.89796, 112.7778 +16322, 68.03452, 119.2309 +16323, 68.37598, 142.8062 +16324, 65.31335, 109.2026 +16325, 64.68155, 110.3814 +16326, 67.81472, 130.8844 +16327, 68.72087, 134.8805 +16328, 66.31745, 112.7879 +16329, 64.69964, 128.1228 +16330, 63.19011, 97.85324 +16331, 67.04974, 123.1772 +16332, 69.77631, 133.7446 +16333, 71.20739, 122.73 +16334, 70.1551, 122.5107 +16335, 70.25528, 114.2026 +16336, 68.26686, 131.6032 +16337, 68.34684, 141.2898 +16338, 70.30878, 140.619 +16339, 67.08135, 110.5151 +16340, 70.55462, 140.4344 +16341, 68.8199, 130.0868 +16342, 66.44443, 126.4245 +16343, 67.62411, 130.7663 +16344, 69.99611, 135.4407 +16345, 70.85949, 146.443 +16346, 67.22633, 127.3791 +16347, 65.79897, 109.5994 +16348, 68.8133, 121.8595 +16349, 68.15897, 137.1696 +16350, 68.13434, 137.7671 +16351, 66.03575, 129.8433 +16352, 71.1392, 136.5394 +16353, 65.7611, 139.533 +16354, 66.4562, 116.1557 +16355, 71.43418, 139.566 +16356, 66.21723, 117.6091 +16357, 65.29847, 110.1183 +16358, 69.93212, 124.5161 +16359, 68.65961, 126.7685 +16360, 68.31157, 127.5313 +16361, 68.86473, 131.0624 +16362, 66.81505, 125.3619 +16363, 71.22412, 144.8558 +16364, 66.51076, 136.4399 +16365, 65.78246, 117.0782 +16366, 66.03177, 131.3673 +16367, 67.44959, 105.4248 +16368, 67.60525, 118.4955 +16369, 67.3143, 138.3905 +16370, 70.86729, 131.1195 +16371, 65.48255, 141.0259 +16372, 68.22266, 141.3689 +16373, 71.31566, 122.9654 +16374, 71.48733, 141.9901 +16375, 64.96432, 119.0701 +16376, 69.49516, 139.2006 +16377, 67.88913, 118.218 +16378, 68.90454, 145.1237 +16379, 68.07183, 127.9641 +16380, 64.39356, 96.18308 +16381, 66.65415, 107.8738 +16382, 68.40425, 110.1585 +16383, 64.65508, 144.2053 +16384, 66.44203, 126.6712 +16385, 71.50072, 133.5473 +16386, 73.88318, 134.2179 +16387, 66.35681, 129.7247 +16388, 64.5294, 129.0555 +16389, 65.86448, 106.1127 +16390, 66.79915, 111.6206 +16391, 72.1822, 134.0295 +16392, 69.3837, 132.8476 +16393, 68.19583, 146.2667 +16394, 70.5114, 128.1338 +16395, 65.80641, 130.8923 +16396, 70.16053, 123.3076 +16397, 67.43844, 122.1914 +16398, 70.71361, 135.7651 +16399, 68.07891, 153.5097 +16400, 68.35342, 131.2236 +16401, 67.20032, 130.9151 +16402, 68.69189, 125.636 +16403, 70.46936, 133.4589 +16404, 66.90871, 133.8009 +16405, 69.88209, 136.8009 +16406, 68.06727, 130.8548 +16407, 69.20068, 133.185 +16408, 67.47538, 131.3843 +16409, 68.32743, 117.697 +16410, 69.00192, 138.9638 +16411, 65.35322, 105.7026 +16412, 65.4318, 116.5828 +16413, 66.26909, 122.9144 +16414, 68.69404, 125.9645 +16415, 66.1094, 134.3551 +16416, 64.41092, 134.127 +16417, 69.49636, 133.8557 +16418, 64.59448, 104.7582 +16419, 67.74181, 124.6148 +16420, 67.86035, 114.8292 +16421, 66.5956, 131.0129 +16422, 67.29007, 108.9249 +16423, 68.4697, 126.7364 +16424, 68.39686, 139.9312 +16425, 65.81488, 118.5393 +16426, 68.31099, 125.4367 +16427, 65.55142, 129.8399 +16428, 68.78688, 151.5744 +16429, 68.9762, 136.3059 +16430, 69.73827, 126.5047 +16431, 68.61113, 149.0624 +16432, 70.29214, 136.9524 +16433, 69.02156, 126.4165 +16434, 65.24243, 111.3249 +16435, 67.79481, 109.7919 +16436, 65.14929, 125.4005 +16437, 67.85083, 104.3679 +16438, 67.95407, 126.1482 +16439, 68.07138, 104.5138 +16440, 67.96206, 125.8946 +16441, 68.0562, 123.0662 +16442, 69.54373, 140.905 +16443, 67.44763, 136.8386 +16444, 69.93226, 143.142 +16445, 68.4428, 123.9019 +16446, 67.14705, 121.2435 +16447, 68.09321, 127.1611 +16448, 70.98751, 160.6929 +16449, 69.63262, 136.2754 +16450, 66.83325, 135.069 +16451, 67.48442, 128.1263 +16452, 70.30599, 146.687 +16453, 70.9558, 146.0678 +16454, 65.56472, 128.1536 +16455, 67.08322, 121.2183 +16456, 70.07861, 108.5745 +16457, 71.39547, 149.9232 +16458, 69.43051, 141.5282 +16459, 66.80894, 122.0407 +16460, 69.62216, 138.2071 +16461, 65.8652, 118.6262 +16462, 66.59005, 141.7685 +16463, 71.13173, 130.8381 +16464, 66.01563, 129.1451 +16465, 66.28735, 116.4058 +16466, 68.99924, 117.7849 +16467, 67.84324, 144.1374 +16468, 67.4654, 105.317 +16469, 67.49195, 123.4161 +16470, 65.34945, 115.779 +16471, 67.83551, 126.1946 +16472, 69.79369, 126.8353 +16473, 68.87143, 125.5759 +16474, 67.82667, 124.1151 +16475, 68.81413, 121.4105 +16476, 70.47876, 130.5729 +16477, 73.16304, 161.2538 +16478, 71.95209, 146.3936 +16479, 67.44715, 119.2209 +16480, 68.85059, 114.7156 +16481, 69.72712, 130.6584 +16482, 67.43691, 136.2537 +16483, 71.11399, 122.0355 +16484, 67.71312, 138.2236 +16485, 66.77008, 112.6772 +16486, 70.90585, 132.9018 +16487, 67.47875, 104.2591 +16488, 68.08728, 111.6015 +16489, 68.54271, 125.7349 +16490, 67.38204, 139.3863 +16491, 67.62489, 123.9918 +16492, 65.71741, 96.56954 +16493, 66.75033, 119.5639 +16494, 70.03827, 138.7756 +16495, 66.8036, 110.2972 +16496, 71.80215, 139.9054 +16497, 69.75691, 137.0891 +16498, 68.62702, 100.7525 +16499, 68.03554, 113.0308 +16500, 70.44384, 141.5947 +16501, 69.53504, 130.0973 +16502, 65.56302, 115.0701 +16503, 67.68639, 123.3297 +16504, 68.31423, 120.6889 +16505, 71.41559, 149.3469 +16506, 70.86132, 135.3213 +16507, 70.19919, 135.138 +16508, 67.31745, 132.8306 +16509, 66.67461, 111.7658 +16510, 68.52431, 98.28103 +16511, 68.08513, 128.1996 +16512, 65.22726, 135.7065 +16513, 67.02577, 114.7573 +16514, 63.12846, 115.988 +16515, 68.91849, 135.5944 +16516, 65.4037, 126.7384 +16517, 66.72667, 137.0383 +16518, 68.0043, 117.1869 +16519, 68.24197, 128.0584 +16520, 68.80229, 123.4378 +16521, 68.76843, 132.3484 +16522, 66.26798, 118.6096 +16523, 64.62832, 138.6254 +16524, 68.20142, 131.4314 +16525, 70.85424, 134.0073 +16526, 66.81173, 114.561 +16527, 69.9304, 139.4913 +16528, 69.89558, 137.409 +16529, 65.211, 109.6018 +16530, 64.95554, 109.2972 +16531, 63.80198, 116.5058 +16532, 69.32363, 133.9561 +16533, 68.08572, 119.1548 +16534, 66.42673, 133.7442 +16535, 68.7483, 121.1914 +16536, 71.42063, 138.9418 +16537, 69.99781, 134.018 +16538, 66.0776, 113.0542 +16539, 68.02381, 116.4733 +16540, 63.40728, 127.6054 +16541, 65.35444, 115.174 +16542, 68.65199, 129.7975 +16543, 67.8743, 129.9449 +16544, 69.21034, 139.2897 +16545, 68.81727, 128.4544 +16546, 69.74177, 135.2069 +16547, 68.01296, 138.7343 +16548, 65.96554, 119.0405 +16549, 70.1201, 114.3885 +16550, 69.52643, 131.3148 +16551, 68.13839, 118.1307 +16552, 68.01789, 137.0494 +16553, 65.5277, 90.67684 +16554, 70.11106, 140.9521 +16555, 69.55787, 136.3448 +16556, 67.8112, 123.8181 +16557, 69.41543, 131.7001 +16558, 69.16396, 125.1731 +16559, 67.10355, 129.3964 +16560, 66.59023, 102.0816 +16561, 65.69038, 128.0027 +16562, 65.87218, 114.5395 +16563, 65.7737, 116.1954 +16564, 67.08497, 118.8063 +16565, 66.64738, 96.76496 +16566, 69.90009, 139.5857 +16567, 69.36888, 135.4301 +16568, 69.41881, 145.6596 +16569, 69.35477, 133.5585 +16570, 66.78976, 124.5194 +16571, 69.98352, 112.0653 +16572, 70.76035, 144.9425 +16573, 68.82168, 134.7195 +16574, 69.50397, 139.8523 +16575, 71.0584, 149.2104 +16576, 66.55888, 120.3692 +16577, 69.08809, 139.7369 +16578, 67.78232, 130.9741 +16579, 66.14817, 119.4163 +16580, 67.02309, 126.8851 +16581, 66.63003, 133.8063 +16582, 68.09397, 135.3716 +16583, 71.62587, 143.5679 +16584, 68.36727, 128.1388 +16585, 72.00969, 151.6078 +16586, 72.15628, 148.6441 +16587, 63.81356, 104.9316 +16588, 67.12639, 132.7966 +16589, 68.67044, 114.1316 +16590, 68.76102, 116.1148 +16591, 64.70654, 128.1374 +16592, 67.46362, 136.9027 +16593, 65.60326, 121.0995 +16594, 69.56871, 132.12 +16595, 65.56437, 137.7446 +16596, 70.18009, 120.0385 +16597, 68.01941, 128.8836 +16598, 69.10492, 133.099 +16599, 67.10458, 132.1679 +16600, 71.08347, 130.0081 +16601, 66.56587, 132.1454 +16602, 67.37511, 117.2506 +16603, 69.67643, 135.9639 +16604, 68.01459, 126.2054 +16605, 67.44922, 125.0511 +16606, 67.82831, 131.2811 +16607, 69.48856, 131.6375 +16608, 65.63996, 129.2401 +16609, 66.28026, 116.499 +16610, 68.01966, 113.4327 +16611, 68.88532, 134.1067 +16612, 68.93233, 123.785 +16613, 71.28853, 128.2775 +16614, 68.47003, 119.0145 +16615, 69.90329, 137.8499 +16616, 70.09202, 130.0885 +16617, 67.96698, 121.0001 +16618, 66.22404, 119.1531 +16619, 67.40603, 124.1916 +16620, 68.18165, 133.6314 +16621, 67.49878, 122.5922 +16622, 70.19817, 138.2708 +16623, 67.46387, 133.6333 +16624, 67.63478, 126.7765 +16625, 68.42936, 136.7083 +16626, 69.11146, 130.5486 +16627, 65.34682, 112.6957 +16628, 72.27679, 161.0088 +16629, 67.17652, 127.4839 +16630, 69.97887, 144.2267 +16631, 69.67383, 129.6119 +16632, 69.89009, 147.7944 +16633, 67.64807, 130.4777 +16634, 67.32703, 118.8394 +16635, 68.97336, 124.6298 +16636, 67.66967, 103.1117 +16637, 66.91254, 126.6126 +16638, 67.55359, 118.7322 +16639, 65.03493, 117.367 +16640, 68.02707, 131.5474 +16641, 67.16576, 143.1687 +16642, 67.45939, 125.3672 +16643, 66.40605, 113.0716 +16644, 65.39009, 131.09 +16645, 67.73618, 122.0743 +16646, 69.51989, 128.0201 +16647, 67.10018, 124.7517 +16648, 68.17712, 124.787 +16649, 68.95359, 139.1428 +16650, 69.43474, 135.4955 +16651, 66.85504, 111.9391 +16652, 67.64108, 143.9 +16653, 69.00734, 121.8109 +16654, 70.25934, 120.8223 +16655, 71.33493, 129.5699 +16656, 69.57026, 136.1203 +16657, 67.42577, 123.4668 +16658, 68.74418, 126.2233 +16659, 71.13567, 160.9951 +16660, 66.54732, 118.107 +16661, 69.35688, 115.1244 +16662, 67.57381, 121.1601 +16663, 68.81213, 122.6589 +16664, 65.97049, 122.2612 +16665, 65.43348, 111.2886 +16666, 67.26682, 126.8626 +16667, 70.48056, 152.8963 +16668, 69.31844, 134.0819 +16669, 69.98038, 149.3003 +16670, 64.3997, 115.6996 +16671, 69.96882, 124.6241 +16672, 71.17805, 139.8145 +16673, 68.17807, 125.2121 +16674, 69.71877, 134.9651 +16675, 66.17811, 120.8511 +16676, 68.06493, 135.2143 +16677, 66.93792, 118.5464 +16678, 71.94764, 122.5813 +16679, 72.71997, 139.6902 +16680, 68.0762, 129.4436 +16681, 71.29571, 120.3065 +16682, 68.7298, 123.5816 +16683, 66.50822, 126.5994 +16684, 63.39372, 112.3913 +16685, 70.08816, 144.335 +16686, 73.11184, 155.5572 +16687, 67.76753, 109.0503 +16688, 67.15813, 122.3345 +16689, 68.88047, 126.3416 +16690, 67.53793, 125.1591 +16691, 69.00373, 121.6103 +16692, 66.91915, 110.2502 +16693, 69.65967, 139.838 +16694, 69.25047, 119.2207 +16695, 70.17827, 136.39 +16696, 70.83539, 151.0733 +16697, 66.47563, 113.5574 +16698, 69.6208, 137.7365 +16699, 67.58201, 132.9915 +16700, 69.74971, 133.1771 +16701, 68.22141, 126.4871 +16702, 66.27854, 137.3219 +16703, 70.31002, 124.259 +16704, 66.09817, 117.8259 +16705, 67.33954, 122.5026 +16706, 69.08954, 128.0095 +16707, 65.74714, 97.61486 +16708, 72.40729, 137.7315 +16709, 69.67981, 151.5938 +16710, 68.74902, 143.562 +16711, 67.52317, 135.6893 +16712, 68.05693, 111.02 +16713, 67.64343, 112.8759 +16714, 68.27843, 116.785 +16715, 66.4448, 118.6193 +16716, 70.06553, 139.9915 +16717, 69.7225, 133.2241 +16718, 69.07385, 131.4765 +16719, 68.89215, 121.5688 +16720, 65.51454, 116.4836 +16721, 68.92231, 151.3009 +16722, 65.2828, 129.6922 +16723, 68.00088, 112.1066 +16724, 69.8297, 119.9775 +16725, 65.88089, 108.9088 +16726, 70.64935, 151.5471 +16727, 67.96283, 129.5435 +16728, 68.2472, 127.8725 +16729, 69.55032, 133.0538 +16730, 70.02152, 134.9774 +16731, 68.66464, 110.6549 +16732, 66.73719, 134.6728 +16733, 68.61698, 126.5903 +16734, 64.54407, 129.9997 +16735, 69.37595, 127.3132 +16736, 67.89117, 125.831 +16737, 67.40181, 133.8403 +16738, 68.42249, 129.9916 +16739, 67.05087, 115.058 +16740, 67.8955, 122.598 +16741, 70.42079, 155.3236 +16742, 68.60394, 104.6119 +16743, 64.82265, 129.7365 +16744, 70.38424, 128.7931 +16745, 71.90845, 130.2846 +16746, 67.98612, 127.0032 +16747, 69.53721, 138.9628 +16748, 66.62497, 125.5671 +16749, 65.79605, 112.9191 +16750, 66.84543, 132.9089 +16751, 67.6002, 120.1248 +16752, 66.30012, 141.2673 +16753, 74.8489, 122.1664 +16754, 65.31147, 119.5294 +16755, 66.60502, 129.9128 +16756, 65.18103, 121.9562 +16757, 69.60249, 127.613 +16758, 68.16866, 119.7595 +16759, 67.46028, 123.7713 +16760, 67.72802, 112.5012 +16761, 66.00024, 126.5343 +16762, 70.91361, 124.7404 +16763, 67.80093, 134.8097 +16764, 68.87869, 137.271 +16765, 71.6397, 151.672 +16766, 68.29438, 127.4005 +16767, 65.12886, 144.2723 +16768, 70.57005, 145.8051 +16769, 73.05003, 153.7847 +16770, 66.13913, 126.1211 +16771, 67.15543, 143.3497 +16772, 67.61729, 115.5436 +16773, 72.08878, 129.3443 +16774, 65.56805, 103.6442 +16775, 68.27811, 139.1479 +16776, 66.11831, 117.6246 +16777, 67.41631, 117.7373 +16778, 67.14346, 123.637 +16779, 67.82005, 106.7011 +16780, 67.84632, 124.327 +16781, 69.31979, 146.8154 +16782, 67.7887, 117.1692 +16783, 69.47633, 127.5222 +16784, 67.58136, 124.4768 +16785, 69.76561, 125.7431 +16786, 65.89876, 127.5898 +16787, 64.31284, 107.3859 +16788, 64.16388, 110.6961 +16789, 63.87961, 112.6594 +16790, 67.43935, 122.1224 +16791, 69.91231, 136.4495 +16792, 70.18686, 122.3744 +16793, 70.58163, 142.9256 +16794, 68.39877, 144.8047 +16795, 69.9265, 152.4115 +16796, 66.84336, 113.3828 +16797, 65.37327, 117.2876 +16798, 69.85898, 109.0503 +16799, 66.18835, 117.1775 +16800, 67.39835, 133.0561 +16801, 64.43316, 122.8413 +16802, 66.94628, 120.0223 +16803, 67.21511, 109.3795 +16804, 69.1414, 132.0737 +16805, 69.60375, 136.9242 +16806, 68.52138, 128.8991 +16807, 67.69719, 117.6493 +16808, 69.5896, 117.4173 +16809, 66.24536, 122.8327 +16810, 69.5915, 139.744 +16811, 70.11961, 115.9145 +16812, 69.77869, 115.5308 +16813, 70.92696, 145.3057 +16814, 68.12409, 127.4662 +16815, 67.03516, 126.9587 +16816, 71.11926, 147.0918 +16817, 67.08274, 145.5487 +16818, 62.59583, 115.9968 +16819, 68.20021, 130.1191 +16820, 69.0616, 105.8284 +16821, 68.03726, 122.7997 +16822, 70.14716, 128.8113 +16823, 67.86308, 129.1697 +16824, 67.97814, 134.905 +16825, 68.54857, 112.7721 +16826, 69.63469, 102.4555 +16827, 67.85196, 138.0472 +16828, 68.15862, 125.2674 +16829, 70.15549, 132.9178 +16830, 71.0108, 150.7492 +16831, 66.5613, 122.0259 +16832, 68.75828, 131.4859 +16833, 69.70189, 117.1029 +16834, 67.25892, 125.4424 +16835, 71.01041, 149.5342 +16836, 66.776, 133.1845 +16837, 69.61543, 144.8825 +16838, 67.75246, 115.1501 +16839, 68.96307, 129.6337 +16840, 67.31179, 137.4955 +16841, 70.40367, 122.8706 +16842, 67.13402, 126.5206 +16843, 64.17145, 107.1466 +16844, 67.39792, 144.818 +16845, 66.64574, 130.3053 +16846, 70.47683, 127.1804 +16847, 72.08897, 125.1799 +16848, 68.85095, 122.5428 +16849, 71.93306, 138.5143 +16850, 67.65224, 129.6587 +16851, 68.43764, 121.4169 +16852, 65.59721, 113.7814 +16853, 73.6454, 131.3343 +16854, 69.86288, 133.5317 +16855, 66.14574, 121.4186 +16856, 68.67138, 114.288 +16857, 68.80011, 117.6921 +16858, 66.91779, 123.5822 +16859, 66.04945, 124.0043 +16860, 65.30509, 123.3602 +16861, 68.64586, 132.2452 +16862, 66.70357, 104.9227 +16863, 66.60702, 122.1239 +16864, 71.36658, 141.775 +16865, 64.98614, 120.1492 +16866, 67.18185, 133.6072 +16867, 66.73989, 113.6685 +16868, 68.74927, 140.856 +16869, 65.12487, 120.8855 +16870, 68.26456, 148.7064 +16871, 68.68431, 140.626 +16872, 65.31203, 117.7404 +16873, 67.47503, 128.9104 +16874, 65.82022, 125.859 +16875, 67.1693, 117.1032 +16876, 67.82189, 139.6111 +16877, 69.64113, 145.7304 +16878, 67.83312, 117.2119 +16879, 68.91669, 129.7441 +16880, 67.11653, 138.9936 +16881, 67.80382, 122.4382 +16882, 65.90289, 115.8894 +16883, 67.9672, 130.3415 +16884, 68.2107, 126.7824 +16885, 69.2622, 117.3759 +16886, 63.75507, 94.05081 +16887, 71.24135, 129.6411 +16888, 67.99301, 122.6971 +16889, 67.71177, 126.3918 +16890, 69.07788, 131.0112 +16891, 72.29087, 146.8726 +16892, 63.41812, 116.5908 +16893, 68.11899, 136.6926 +16894, 68.70919, 124.6256 +16895, 65.98196, 108.0272 +16896, 66.78125, 140.4767 +16897, 68.77375, 118.9486 +16898, 70.74718, 130.7772 +16899, 68.70966, 134.7851 +16900, 67.56819, 135.5679 +16901, 70.10034, 135.3067 +16902, 65.7134, 118.2903 +16903, 67.77136, 114.8094 +16904, 68.40923, 129.7769 +16905, 70.18595, 128.0279 +16906, 67.10295, 136.7551 +16907, 67.02015, 138.9499 +16908, 67.12731, 146.9289 +16909, 68.63305, 126.9655 +16910, 70.39135, 129.4393 +16911, 66.77894, 116.5019 +16912, 68.00799, 128.7606 +16913, 68.46274, 111.8667 +16914, 66.66252, 132.5196 +16915, 65.30234, 123.0112 +16916, 69.79619, 137.8177 +16917, 66.49651, 119.2178 +16918, 70.21724, 141.7782 +16919, 66.59252, 119.3649 +16920, 68.04983, 138.8169 +16921, 67.13235, 120.2113 +16922, 67.06311, 144.4981 +16923, 72.02884, 143.6152 +16924, 68.22696, 134.011 +16925, 69.39149, 141.595 +16926, 69.59227, 142.5185 +16927, 69.35974, 130.6723 +16928, 66.03004, 106.6019 +16929, 70.57617, 142.7081 +16930, 67.70133, 133.1967 +16931, 69.06556, 123.8482 +16932, 71.46669, 132.9282 +16933, 69.7224, 143.5373 +16934, 67.3639, 124.0105 +16935, 63.96076, 122.1277 +16936, 66.18589, 138.4375 +16937, 66.7947, 106.7529 +16938, 66.8782, 120.5632 +16939, 65.922, 114.9806 +16940, 69.87458, 131.6044 +16941, 67.50107, 128.0883 +16942, 67.53167, 121.1148 +16943, 64.66379, 113.5736 +16944, 69.01351, 142.5127 +16945, 66.9502, 117.4488 +16946, 68.36938, 122.3564 +16947, 67.50898, 145.7299 +16948, 66.42924, 131.8816 +16949, 63.68444, 117.4249 +16950, 66.97479, 122.3144 +16951, 69.49132, 124.8853 +16952, 68.71402, 131.9578 +16953, 66.58675, 135.4122 +16954, 67.63831, 130.5276 +16955, 70.58074, 133.9982 +16956, 69.4379, 138.0011 +16957, 66.73525, 110.2324 +16958, 66.89482, 114.4542 +16959, 66.70729, 116.0486 +16960, 70.52264, 146.0748 +16961, 67.99362, 128.7902 +16962, 67.31407, 123.3903 +16963, 68.92624, 144.3117 +16964, 69.95962, 135.4521 +16965, 67.3748, 133.9821 +16966, 68.75228, 126.4009 +16967, 70.92144, 134.0307 +16968, 68.52252, 115.4861 +16969, 69.5209, 145.7846 +16970, 66.05943, 97.01374 +16971, 68.27952, 138.6687 +16972, 71.08797, 138.9202 +16973, 67.74228, 110.9634 +16974, 71.04532, 137.5639 +16975, 68.01494, 116.0504 +16976, 67.42681, 119.6089 +16977, 67.79463, 122.4231 +16978, 67.40071, 121.1187 +16979, 68.11235, 122.6629 +16980, 69.66975, 135.1748 +16981, 70.08741, 128.3117 +16982, 66.90838, 133.2205 +16983, 65.48822, 130.85 +16984, 66.35895, 130.5585 +16985, 65.52836, 114.1016 +16986, 66.52176, 114.8809 +16987, 71.81138, 132.3429 +16988, 70.19514, 134.2615 +16989, 69.85682, 139.1729 +16990, 64.30305, 108.1925 +16991, 67.19538, 128.889 +16992, 67.82321, 146.2227 +16993, 65.77148, 130.2604 +16994, 66.3694, 113.7416 +16995, 68.50592, 113.7442 +16996, 67.68043, 130.7277 +16997, 68.80924, 138.9852 +16998, 67.59109, 117.7681 +16999, 67.01374, 110.6789 +17000, 70.23199, 134.3019 +17001, 68.08186, 140.965 +17002, 64.89975, 103.2639 +17003, 67.93563, 127.6112 +17004, 68.24257, 132.3379 +17005, 67.34695, 107.9964 +17006, 69.00004, 147.6115 +17007, 69.11678, 117.4892 +17008, 69.14144, 124.4207 +17009, 67.20212, 124.519 +17010, 64.8577, 111.4153 +17011, 69.24196, 137.1028 +17012, 67.50147, 140.3687 +17013, 66.74043, 123.4565 +17014, 67.64341, 130.851 +17015, 69.60678, 130.557 +17016, 67.98121, 115.1045 +17017, 67.37402, 108.3712 +17018, 67.84743, 132.2256 +17019, 71.84403, 131.7296 +17020, 72.02089, 152.0369 +17021, 65.79883, 130.2469 +17022, 67.91801, 140.0335 +17023, 70.91753, 141.4748 +17024, 69.48346, 133.2048 +17025, 70.345, 138.3456 +17026, 69.42982, 130.7436 +17027, 69.83005, 140.1611 +17028, 68.26316, 127.53 +17029, 71.29705, 145.9248 +17030, 69.28155, 125.0306 +17031, 68.08146, 129.9596 +17032, 69.35917, 122.6629 +17033, 69.65365, 135.0822 +17034, 67.50973, 131.7685 +17035, 70.17333, 134.3438 +17036, 63.83399, 93.14015 +17037, 68.23777, 145.3722 +17038, 68.92202, 134.5452 +17039, 68.62749, 119.4845 +17040, 70.00309, 142.5081 +17041, 69.31001, 134.6324 +17042, 67.31293, 114.2869 +17043, 68.96777, 138.8055 +17044, 68.17941, 147.7557 +17045, 67.45506, 102.6064 +17046, 67.66003, 119.0371 +17047, 68.95279, 123.2895 +17048, 69.78643, 119.9806 +17049, 67.28659, 103.0959 +17050, 67.61536, 143.7498 +17051, 70.61988, 129.2067 +17052, 70.04763, 140.4727 +17053, 67.1607, 126.5374 +17054, 66.93887, 130.979 +17055, 72.07925, 126.6152 +17056, 71.16948, 107.4929 +17057, 65.24695, 123.1823 +17058, 66.28952, 125.5371 +17059, 66.64777, 128.3512 +17060, 68.12185, 141.3107 +17061, 66.72556, 124.2101 +17062, 66.25773, 120.1568 +17063, 64.60513, 121.87 +17064, 68.3871, 124.28 +17065, 68.8693, 132.342 +17066, 69.08858, 128.4363 +17067, 65.67589, 107.7892 +17068, 67.07057, 119.175 +17069, 67.46812, 133.0635 +17070, 67.25401, 138.7418 +17071, 67.55824, 129.857 +17072, 68.50476, 127.7725 +17073, 66.59871, 120.4203 +17074, 67.45933, 145.1994 +17075, 70.19351, 155.8501 +17076, 66.68331, 112.3272 +17077, 65.01213, 131.4172 +17078, 70.23551, 137.7941 +17079, 66.38253, 100.1526 +17080, 74.2957, 170.5479 +17081, 68.3967, 133.9416 +17082, 69.51862, 126.795 +17083, 68.35522, 152.8346 +17084, 66.981, 125.7192 +17085, 66.15165, 127.648 +17086, 68.12739, 135.7452 +17087, 71.00404, 147.3999 +17088, 69.18084, 121.0461 +17089, 69.25157, 142.0283 +17090, 65.89909, 116.6285 +17091, 65.01016, 113.665 +17092, 70.67025, 145.5058 +17093, 67.91307, 117.1901 +17094, 66.83902, 135.9237 +17095, 69.24982, 141.832 +17096, 68.20219, 123.4755 +17097, 65.00478, 114.8875 +17098, 67.44928, 121.8513 +17099, 65.66549, 115.9641 +17100, 68.33879, 120.0566 +17101, 66.00157, 138.16 +17102, 69.60672, 147.4894 +17103, 66.81635, 117.8826 +17104, 71.57686, 130.2389 +17105, 71.3565, 153.339 +17106, 67.98793, 126.4604 +17107, 65.56672, 120.8202 +17108, 70.39966, 122.8004 +17109, 65.7372, 115.6365 +17110, 67.38494, 145.9888 +17111, 70.00988, 135.2099 +17112, 67.69492, 112.0235 +17113, 68.71585, 126.3978 +17114, 69.6456, 133.6615 +17115, 65.67921, 97.5587 +17116, 66.4272, 140.3629 +17117, 69.16499, 130.7432 +17118, 64.99349, 95.53404 +17119, 69.29714, 135.1842 +17120, 67.03529, 127.6698 +17121, 70.17991, 141.2059 +17122, 68.42657, 139.0159 +17123, 67.42189, 115.3929 +17124, 71.6334, 144.9499 +17125, 68.4183, 118.4396 +17126, 69.58501, 116.3081 +17127, 68.2946, 134.5639 +17128, 68.29736, 114.556 +17129, 67.23158, 111.2912 +17130, 68.15698, 124.7231 +17131, 67.58915, 113.8607 +17132, 66.48084, 131.7704 +17133, 67.83819, 112.8704 +17134, 66.22459, 120.3185 +17135, 69.32855, 148.7261 +17136, 68.7643, 138.8232 +17137, 66.60467, 117.4884 +17138, 68.06631, 111.7891 +17139, 65.82945, 113.0426 +17140, 67.10438, 111.593 +17141, 68.05392, 98.44388 +17142, 67.04599, 116.846 +17143, 69.75999, 140.1723 +17144, 68.62962, 128.635 +17145, 67.21518, 113.1391 +17146, 66.65893, 130.1087 +17147, 66.61554, 124.7657 +17148, 68.8524, 153.9203 +17149, 68.11909, 139.9683 +17150, 68.84217, 133.1024 +17151, 69.28642, 117.1763 +17152, 67.43359, 134.4193 +17153, 68.4407, 131.7304 +17154, 72.56003, 143.5421 +17155, 65.07677, 102.0212 +17156, 68.07466, 139.4078 +17157, 69.87283, 133.8259 +17158, 67.54613, 136.548 +17159, 68.99154, 136.0463 +17160, 65.93494, 114.2724 +17161, 67.50424, 124.5354 +17162, 67.8023, 127.3532 +17163, 68.36515, 133.1667 +17164, 68.72643, 119.8404 +17165, 65.63641, 115.1096 +17166, 71.53079, 139.728 +17167, 68.27154, 119.8697 +17168, 65.48714, 125.6218 +17169, 68.25275, 140.0211 +17170, 69.62553, 134.1744 +17171, 71.33776, 151.6827 +17172, 65.22591, 113.2357 +17173, 68.33965, 116.1773 +17174, 67.44352, 131.3575 +17175, 67.0122, 115.7769 +17176, 70.45836, 113.9029 +17177, 65.74525, 132.905 +17178, 68.08006, 131.2455 +17179, 70.3959, 132.2152 +17180, 72.96003, 141.0356 +17181, 69.00062, 139.347 +17182, 69.51925, 142.2807 +17183, 69.3335, 132.628 +17184, 71.19641, 136.2158 +17185, 69.76816, 131.0426 +17186, 70.62661, 113.2917 +17187, 67.28616, 145.1271 +17188, 68.66966, 116.3694 +17189, 69.29476, 134.6555 +17190, 64.09493, 115.4626 +17191, 63.6884, 107.0641 +17192, 69.35389, 130.634 +17193, 65.60857, 102.9622 +17194, 69.51197, 140.5772 +17195, 69.14868, 125.3518 +17196, 66.54976, 118.1047 +17197, 68.73761, 113.9191 +17198, 68.61752, 143.5086 +17199, 64.7415, 122.214 +17200, 69.43114, 129.3049 +17201, 67.66681, 133.1967 +17202, 69.5546, 140.8539 +17203, 68.32029, 145.1288 +17204, 69.69178, 137.9446 +17205, 72.88636, 136.2642 +17206, 62.60367, 120.4839 +17207, 69.89894, 129.4752 +17208, 68.74855, 116.7264 +17209, 70.15073, 114.7623 +17210, 70.25185, 126.8904 +17211, 70.05622, 128.2033 +17212, 71.56915, 139.758 +17213, 66.7109, 105.7077 +17214, 67.85257, 129.604 +17215, 70.69405, 133.8317 +17216, 69.26246, 118.5224 +17217, 64.55678, 107.7334 +17218, 66.24054, 118.7468 +17219, 71.68073, 149.2518 +17220, 71.21093, 133.7609 +17221, 70.00062, 139.8029 +17222, 71.0916, 154.3139 +17223, 67.21865, 106.4772 +17224, 66.45714, 115.509 +17225, 67.47694, 127.3133 +17226, 67.50358, 121.8309 +17227, 67.20873, 125.5948 +17228, 66.71667, 135.6625 +17229, 66.70363, 131.4875 +17230, 69.96498, 143.9715 +17231, 68.36676, 146.4269 +17232, 66.05514, 110.1934 +17233, 68.55523, 121.336 +17234, 67.98234, 148.4537 +17235, 68.30939, 138.8029 +17236, 69.34515, 128.481 +17237, 68.52656, 117.759 +17238, 69.20707, 119.3487 +17239, 71.47479, 145.6045 +17240, 65.5345, 104.6023 +17241, 67.78592, 115.9959 +17242, 66.59132, 127.1836 +17243, 67.13782, 128.8127 +17244, 67.00111, 123.5243 +17245, 66.61654, 114.8299 +17246, 72.32507, 140.0185 +17247, 66.90281, 137.8036 +17248, 67.55171, 155.8602 +17249, 68.48654, 135.2003 +17250, 67.5987, 120.4145 +17251, 68.32615, 126.5379 +17252, 67.53167, 136.8568 +17253, 69.72754, 133.9694 +17254, 69.6497, 138.7263 +17255, 66.74817, 120.5369 +17256, 68.68338, 137.2761 +17257, 68.09093, 112.3863 +17258, 70.61191, 129.0103 +17259, 67.37954, 122.8752 +17260, 68.13334, 138.094 +17261, 68.91805, 141.2478 +17262, 70.53026, 120.2164 +17263, 66.74661, 123.1471 +17264, 63.66612, 92.91629 +17265, 68.93518, 128.9977 +17266, 62.95082, 89.82395 +17267, 68.93593, 128.2837 +17268, 68.73095, 136.5794 +17269, 66.31924, 111.7375 +17270, 70.48056, 143.0927 +17271, 69.12774, 139.3958 +17272, 67.81338, 123.9796 +17273, 69.70128, 137.1688 +17274, 68.20119, 124.0966 +17275, 68.43567, 135.5799 +17276, 66.59979, 122.0255 +17277, 69.57976, 121.9471 +17278, 66.89298, 153.7224 +17279, 68.44356, 133.3465 +17280, 64.02299, 133.0834 +17281, 68.08549, 126.3244 +17282, 64.19319, 131.872 +17283, 68.1466, 126.907 +17284, 66.59019, 112.2 +17285, 71.77869, 136.6592 +17286, 65.45623, 120.6365 +17287, 66.91902, 109.6637 +17288, 70.47505, 147.7924 +17289, 70.45755, 130.7421 +17290, 69.23837, 140.1161 +17291, 70.43378, 123.3224 +17292, 66.66166, 108.7235 +17293, 66.202, 116.2268 +17294, 69.01369, 123.5196 +17295, 67.89474, 109.0678 +17296, 65.09125, 115.2931 +17297, 65.61432, 118.1457 +17298, 67.83938, 120.6424 +17299, 67.93244, 149.6971 +17300, 68.77471, 147.1688 +17301, 65.27402, 123.5437 +17302, 64.87507, 107.5534 +17303, 68.12084, 144.7017 +17304, 68.10385, 122.944 +17305, 66.60491, 123.4707 +17306, 64.98909, 126.5752 +17307, 65.48748, 123.3998 +17308, 71.20181, 135.5595 +17309, 69.63121, 145.3661 +17310, 67.94288, 132.4093 +17311, 69.47689, 137.9974 +17312, 67.00352, 125.768 +17313, 67.33913, 140.9204 +17314, 69.99442, 124.9403 +17315, 66.61274, 122.8743 +17316, 64.62708, 119.5881 +17317, 67.33036, 129.4347 +17318, 67.80582, 122.0169 +17319, 67.32409, 131.2304 +17320, 70.96058, 154.6305 +17321, 68.98601, 128.4208 +17322, 69.46885, 126.7239 +17323, 67.27957, 151.1432 +17324, 70.18223, 118.0108 +17325, 67.0326, 138.4939 +17326, 66.39075, 120.1294 +17327, 67.89527, 134.1851 +17328, 66.14899, 130.3818 +17329, 69.54063, 144.5497 +17330, 70.14756, 134.8804 +17331, 66.89045, 99.50583 +17332, 67.23624, 137.2681 +17333, 69.78805, 125.1333 +17334, 68.41729, 132.5489 +17335, 65.77199, 124.1671 +17336, 68.65215, 123.5174 +17337, 68.65431, 140.2481 +17338, 70.68047, 147.894 +17339, 66.9118, 138.9373 +17340, 69.86836, 127.2331 +17341, 63.23208, 111.9702 +17342, 64.72051, 104.9827 +17343, 65.24398, 124.1485 +17344, 70.89385, 133.8627 +17345, 64.25659, 125.7283 +17346, 70.04462, 135.2964 +17347, 68.1956, 132.6032 +17348, 66.98148, 139.9306 +17349, 67.94824, 139.7195 +17350, 67.09869, 118.7587 +17351, 71.84299, 149.6695 +17352, 68.44482, 131.4924 +17353, 67.24833, 120.8204 +17354, 69.21266, 125.3578 +17355, 64.62267, 110.5318 +17356, 66.34307, 135.219 +17357, 67.53967, 125.4678 +17358, 66.34283, 122.1693 +17359, 66.21181, 102.0376 +17360, 67.4587, 123.1343 +17361, 66.25568, 125.5099 +17362, 67.24089, 110.9775 +17363, 65.92673, 132.2059 +17364, 67.96507, 124.3027 +17365, 67.12922, 137.0875 +17366, 69.75762, 117.7232 +17367, 69.35818, 136.1109 +17368, 66.49944, 130.8294 +17369, 65.84519, 116.6415 +17370, 68.6028, 138.3946 +17371, 65.50146, 105.7827 +17372, 69.52765, 135.0961 +17373, 68.34357, 130.8423 +17374, 68.39615, 146.7625 +17375, 66.43119, 133.4835 +17376, 68.33665, 101.9516 +17377, 69.47857, 135.9337 +17378, 66.01032, 131.8757 +17379, 64.46887, 94.18679 +17380, 67.68763, 118.7816 +17381, 69.57526, 138.27 +17382, 69.0155, 135.8559 +17383, 70.21523, 127.0247 +17384, 72.33756, 124.8651 +17385, 70.90167, 120.6197 +17386, 68.87665, 133.8123 +17387, 67.92675, 127.4273 +17388, 69.62929, 129.0453 +17389, 67.59691, 110.7002 +17390, 63.85158, 96.09962 +17391, 68.01914, 119.6914 +17392, 69.86323, 149.4407 +17393, 69.23452, 141.8186 +17394, 66.7337, 121.9367 +17395, 67.6231, 109.1208 +17396, 69.04787, 135.6889 +17397, 66.66643, 134.4328 +17398, 65.62201, 121.1309 +17399, 68.02126, 130.6948 +17400, 68.08905, 134.0382 +17401, 67.5556, 134.2413 +17402, 69.35112, 142.6964 +17403, 67.77226, 129.9275 +17404, 70.44505, 127.7974 +17405, 68.2744, 132.4472 +17406, 66.20602, 104.8284 +17407, 68.40548, 141.5327 +17408, 67.28425, 125.0764 +17409, 69.86408, 137.2586 +17410, 70.17631, 122.8945 +17411, 68.57961, 125.8787 +17412, 68.45722, 154.869 +17413, 70.16449, 138.963 +17414, 67.94165, 150.0432 +17415, 68.94539, 124.4079 +17416, 66.95864, 121.0411 +17417, 67.13623, 137.279 +17418, 69.5223, 129.8503 +17419, 69.18085, 117.7637 +17420, 66.22712, 122.3249 +17421, 65.79575, 128.0249 +17422, 68.66855, 128.7411 +17423, 70.65926, 147.8487 +17424, 67.12482, 128.5421 +17425, 69.51048, 131.1724 +17426, 69.71101, 137.643 +17427, 66.2875, 129.1074 +17428, 65.99484, 128.2892 +17429, 68.42721, 106.4421 +17430, 70.19993, 129.7897 +17431, 67.513, 126.6537 +17432, 64.9103, 126.3234 +17433, 67.90483, 133.3319 +17434, 68.72117, 110.1285 +17435, 69.82383, 132.965 +17436, 66.35869, 134.4128 +17437, 64.96389, 112.9538 +17438, 68.10303, 120.6951 +17439, 66.75597, 128.8385 +17440, 70.61415, 125.407 +17441, 68.98555, 144.2759 +17442, 66.08359, 124.9939 +17443, 68.9074, 114.1931 +17444, 70.61363, 117.2962 +17445, 70.6372, 151.222 +17446, 70.41624, 148.9906 +17447, 70.83968, 145.3063 +17448, 70.65043, 117.1631 +17449, 65.80934, 138.862 +17450, 66.92804, 128.9616 +17451, 70.39752, 126.0571 +17452, 72.50206, 147.8171 +17453, 64.03816, 120.2204 +17454, 67.21913, 123.7812 +17455, 67.61897, 129.5538 +17456, 68.35799, 134.8242 +17457, 68.28884, 132.8389 +17458, 69.1259, 137.0335 +17459, 69.41682, 128.1469 +17460, 67.77817, 138.1283 +17461, 66.81717, 143.9722 +17462, 66.75222, 128.8606 +17463, 70.87992, 148.1767 +17464, 67.89296, 119.2523 +17465, 68.241, 134.4452 +17466, 69.38423, 145.2439 +17467, 67.65062, 131.6738 +17468, 64.91414, 127.9493 +17469, 69.34408, 128.3066 +17470, 67.92756, 130.1062 +17471, 67.10739, 132.5064 +17472, 70.39954, 116.3744 +17473, 68.23497, 138.2569 +17474, 65.60851, 122.0313 +17475, 69.05463, 130.5581 +17476, 69.12682, 140.6556 +17477, 70.88868, 142.4583 +17478, 67.58599, 132.6764 +17479, 67.32745, 119.78 +17480, 67.12344, 124.6291 +17481, 67.61494, 123.2273 +17482, 67.66575, 128.987 +17483, 69.5664, 147.4409 +17484, 69.15809, 132.131 +17485, 68.67322, 130.7502 +17486, 66.99931, 114.139 +17487, 65.92524, 135.0721 +17488, 71.79475, 128.5656 +17489, 69.80914, 128.4846 +17490, 68.67485, 147.9136 +17491, 69.78355, 144.2045 +17492, 66.4674, 126.0095 +17493, 67.7098, 102.0889 +17494, 68.07478, 121.1104 +17495, 68.83845, 127.8095 +17496, 66.26448, 116.7611 +17497, 67.13351, 109.3082 +17498, 71.7536, 135.465 +17499, 69.04101, 135.8275 +17500, 66.32523, 118.2465 +17501, 66.14545, 105.8383 +17502, 66.29814, 122.1135 +17503, 69.04615, 124.2771 +17504, 68.4843, 137.9207 +17505, 69.22513, 152.3623 +17506, 65.09487, 116.8324 +17507, 69.82687, 137.7917 +17508, 71.35732, 141.2236 +17509, 69.78746, 144.7297 +17510, 67.53645, 132.4694 +17511, 71.56001, 134.0619 +17512, 66.63729, 110.7138 +17513, 70.40909, 152.2089 +17514, 69.48909, 127.0428 +17515, 66.23063, 125.2783 +17516, 68.48589, 121.0761 +17517, 67.04085, 123.1234 +17518, 67.27063, 137.0571 +17519, 71.97956, 143.4563 +17520, 70.96103, 146.4419 +17521, 66.91292, 131.9401 +17522, 68.28653, 131.3733 +17523, 67.93407, 114.6522 +17524, 69.21084, 126.1387 +17525, 69.30884, 126.5639 +17526, 70.80526, 135.2671 +17527, 67.93951, 109.9232 +17528, 67.56284, 107.6989 +17529, 68.09715, 124.0935 +17530, 70.12763, 129.9578 +17531, 66.98102, 131.5794 +17532, 68.86713, 146.9701 +17533, 65.2471, 104.3321 +17534, 68.7895, 112.7259 +17535, 66.34859, 115.9226 +17536, 65.34809, 115.9247 +17537, 68.56905, 142.9977 +17538, 68.42731, 128.6519 +17539, 63.02668, 117.3216 +17540, 70.48699, 108.167 +17541, 68.76397, 116.1651 +17542, 67.79336, 125.918 +17543, 70.62234, 128.4205 +17544, 70.83431, 133.99 +17545, 66.67394, 104.0444 +17546, 68.11247, 115.8479 +17547, 69.17367, 126.6247 +17548, 64.44211, 106.5789 +17549, 64.78017, 116.4003 +17550, 66.10999, 133.4851 +17551, 65.87608, 125.1903 +17552, 66.10888, 117.348 +17553, 68.80248, 128.6236 +17554, 66.81104, 131.7218 +17555, 69.08557, 113.5234 +17556, 65.7806, 111.8252 +17557, 71.0256, 126.3278 +17558, 66.96471, 114.1668 +17559, 67.35775, 125.6802 +17560, 68.96066, 115.0578 +17561, 70.45835, 131.7719 +17562, 65.83663, 125.7059 +17563, 69.09294, 140.4586 +17564, 70.01214, 135.788 +17565, 70.05774, 131.9843 +17566, 68.80506, 118.9164 +17567, 71.03993, 114.2464 +17568, 66.96363, 119.7721 +17569, 68.13431, 143.9173 +17570, 68.12636, 134.6963 +17571, 65.78844, 115.5098 +17572, 66.52245, 141.3431 +17573, 66.4821, 119.7862 +17574, 66.78109, 111.4848 +17575, 70.63527, 129.1964 +17576, 64.84494, 125.1476 +17577, 66.94689, 113.3937 +17578, 69.9777, 146.588 +17579, 68.47808, 126.7218 +17580, 71.90407, 129.2662 +17581, 66.16301, 134.7019 +17582, 70.373, 127.0987 +17583, 69.51213, 154.7542 +17584, 68.62782, 115.5711 +17585, 68.02584, 112.8388 +17586, 68.93595, 128.5597 +17587, 68.45787, 143.0222 +17588, 71.04919, 150.0566 +17589, 68.41924, 133.9914 +17590, 66.17319, 129.4204 +17591, 68.25954, 123.7291 +17592, 69.45543, 126.2942 +17593, 67.36318, 131.4997 +17594, 70.46899, 129.5623 +17595, 65.38946, 122.8568 +17596, 66.58764, 107.3435 +17597, 68.94909, 123.1888 +17598, 71.99101, 132.4664 +17599, 66.52168, 90.28757 +17600, 65.33005, 103.7244 +17601, 70.78015, 122.0199 +17602, 67.59295, 150.5815 +17603, 70.60438, 130.0759 +17604, 65.41199, 127.4417 +17605, 68.62862, 131.5481 +17606, 69.74755, 135.2463 +17607, 68.1019, 124.3764 +17608, 70.11839, 116.9938 +17609, 68.67284, 131.3305 +17610, 67.5545, 130.8208 +17611, 69.10032, 140.3478 +17612, 65.02648, 114.67 +17613, 67.66499, 100.9845 +17614, 66.05669, 127.6383 +17615, 68.56903, 123.1565 +17616, 71.14656, 154.5352 +17617, 68.34943, 142.6295 +17618, 67.52165, 129.4453 +17619, 66.28252, 110.107 +17620, 66.28898, 111.789 +17621, 67.38143, 118.9327 +17622, 64.96211, 116.1956 +17623, 68.06586, 128.5962 +17624, 69.29725, 122.9534 +17625, 68.59195, 124.7235 +17626, 68.36335, 115.9058 +17627, 68.20277, 124.6159 +17628, 67.63228, 113.3939 +17629, 68.55703, 131.2876 +17630, 67.80819, 109.1425 +17631, 69.84982, 124.792 +17632, 67.60338, 124.7089 +17633, 66.71585, 129.8961 +17634, 68.47311, 128.0554 +17635, 66.60304, 145.09 +17636, 67.27537, 118.608 +17637, 70.94362, 119.4777 +17638, 68.47006, 137.1918 +17639, 68.82753, 129.1745 +17640, 70.8099, 140.7936 +17641, 68.3647, 149.1508 +17642, 70.78792, 139.6307 +17643, 67.27509, 123.7572 +17644, 67.20986, 148.5905 +17645, 67.4203, 122.0798 +17646, 69.04477, 126.2105 +17647, 65.38357, 100.095 +17648, 65.61573, 132.7978 +17649, 69.85783, 118.9502 +17650, 67.36017, 105.2444 +17651, 62.6732, 121.4203 +17652, 70.42525, 121.7662 +17653, 67.26572, 126.6487 +17654, 68.51747, 143.4521 +17655, 64.26348, 106.0661 +17656, 70.26415, 145.1632 +17657, 67.41239, 114.509 +17658, 66.90254, 124.9441 +17659, 67.09326, 103.5604 +17660, 69.77547, 130.6445 +17661, 68.33065, 118.0593 +17662, 68.26423, 136.1453 +17663, 71.57294, 143.9069 +17664, 65.40654, 121.508 +17665, 67.34236, 123.9898 +17666, 68.37858, 146.2403 +17667, 66.6348, 124.2302 +17668, 69.29278, 124.7185 +17669, 67.92344, 101.0071 +17670, 69.22177, 109.5712 +17671, 67.81513, 140.0702 +17672, 68.53579, 150.1922 +17673, 68.44375, 116.0455 +17674, 66.7314, 123.9785 +17675, 66.60584, 119.3897 +17676, 68.23841, 130.5193 +17677, 67.80735, 118.0474 +17678, 69.12848, 135.7411 +17679, 68.27442, 125.7874 +17680, 66.25022, 111.829 +17681, 66.69382, 137.1941 +17682, 69.13214, 121.0271 +17683, 65.10633, 124.076 +17684, 66.68091, 114.9335 +17685, 68.83099, 130.5804 +17686, 64.99021, 107.8868 +17687, 65.10463, 119.2647 +17688, 66.23363, 129.517 +17689, 70.40311, 140.5745 +17690, 69.1741, 142.1562 +17691, 70.94219, 155.5272 +17692, 69.77945, 141.9648 +17693, 68.07987, 128.9409 +17694, 71.18967, 135.8515 +17695, 68.68805, 132.4254 +17696, 67.13456, 127.5693 +17697, 69.38753, 140.057 +17698, 69.78403, 112.8273 +17699, 70.54483, 142.3329 +17700, 69.26943, 128.3769 +17701, 62.75187, 123.6565 +17702, 68.67501, 124.052 +17703, 69.80293, 115.4548 +17704, 68.42678, 143.1792 +17705, 69.45741, 138.7257 +17706, 67.9611, 132.2818 +17707, 70.27294, 147.6049 +17708, 69.4698, 115.1695 +17709, 66.0276, 132.7526 +17710, 70.05938, 119.229 +17711, 69.20764, 134.5649 +17712, 67.91794, 128.9604 +17713, 64.29769, 129.4822 +17714, 68.08515, 132.9598 +17715, 64.99793, 130.275 +17716, 67.5616, 113.1737 +17717, 66.51537, 134.7376 +17718, 67.68945, 130.292 +17719, 68.90486, 110.8739 +17720, 66.18914, 115.6845 +17721, 69.75767, 127.8686 +17722, 66.76657, 140.9137 +17723, 67.08656, 119.2133 +17724, 69.01353, 113.2377 +17725, 68.92044, 135.0273 +17726, 65.85728, 126.3403 +17727, 67.17593, 141.6974 +17728, 67.30636, 99.24041 +17729, 66.94324, 130.8662 +17730, 68.50491, 122.4066 +17731, 68.74354, 125.7904 +17732, 65.76227, 104.6801 +17733, 69.09257, 136.0122 +17734, 68.94939, 118.2589 +17735, 70.09213, 125.8561 +17736, 69.18731, 133.4524 +17737, 68.4954, 128.8647 +17738, 69.51338, 125.0658 +17739, 66.63248, 116.099 +17740, 71.0828, 126.8249 +17741, 69.24003, 121.6796 +17742, 67.58275, 107.368 +17743, 67.47076, 135.8448 +17744, 67.46227, 154.3603 +17745, 66.76317, 117.0371 +17746, 68.17367, 146.8522 +17747, 69.46524, 134.8602 +17748, 66.62973, 121.8982 +17749, 66.44354, 107.1741 +17750, 64.64407, 122.6856 +17751, 67.3738, 125.9878 +17752, 67.15214, 118.8415 +17753, 67.02086, 122.0688 +17754, 65.3578, 119.4367 +17755, 68.64967, 135.319 +17756, 65.73185, 107.9237 +17757, 70.26659, 145.7515 +17758, 67.98652, 108.0164 +17759, 68.12168, 103.4226 +17760, 66.71189, 113.731 +17761, 68.95181, 118.5587 +17762, 64.05937, 107.2392 +17763, 67.8327, 99.86461 +17764, 65.13404, 128.6271 +17765, 69.83556, 140.1353 +17766, 64.58079, 117.7762 +17767, 66.27481, 139.9699 +17768, 68.44232, 136.3386 +17769, 69.49662, 126.653 +17770, 67.00532, 136.4169 +17771, 66.56845, 119.5951 +17772, 71.46587, 140.205 +17773, 71.15181, 127.4632 +17774, 67.45321, 120.4057 +17775, 67.04669, 124.6743 +17776, 70.26367, 136.9014 +17777, 67.61734, 124.1445 +17778, 69.14406, 126.3297 +17779, 68.51538, 119.557 +17780, 67.15402, 109.3047 +17781, 67.39338, 116.0406 +17782, 63.98085, 130.7299 +17783, 67.69502, 121.9959 +17784, 63.70691, 115.2735 +17785, 68.96742, 148.4415 +17786, 67.80944, 110.1538 +17787, 65.94609, 123.3123 +17788, 66.7438, 125.529 +17789, 69.28237, 129.4881 +17790, 67.30155, 138.8039 +17791, 64.46644, 122.0999 +17792, 70.54669, 152.5065 +17793, 70.72644, 125.0889 +17794, 70.68136, 124.8044 +17795, 67.64608, 123.3561 +17796, 70.01336, 137.4849 +17797, 70.26996, 132.6404 +17798, 64.43709, 117.2493 +17799, 65.71351, 107.3677 +17800, 67.51238, 115.8008 +17801, 67.41874, 136.2018 +17802, 67.24278, 127.5762 +17803, 66.92857, 122.3716 +17804, 67.00632, 121.4926 +17805, 71.00224, 142.3814 +17806, 65.08169, 131.7073 +17807, 68.68027, 138.8542 +17808, 68.95186, 119.4662 +17809, 65.72262, 125.0601 +17810, 67.25835, 112.9622 +17811, 68.83265, 141.0966 +17812, 66.0971, 114.9541 +17813, 68.72897, 103.6782 +17814, 70.73673, 121.2629 +17815, 67.11241, 102.611 +17816, 68.28176, 132.165 +17817, 66.27818, 111.2475 +17818, 68.17814, 130.9026 +17819, 67.39827, 133.3838 +17820, 68.26178, 140.6728 +17821, 69.16235, 139.975 +17822, 69.95678, 144.1954 +17823, 65.80928, 127.7615 +17824, 70.35926, 115.0103 +17825, 72.16204, 128.699 +17826, 70.5984, 127.022 +17827, 67.54096, 116.5187 +17828, 70.90351, 149.8015 +17829, 66.69164, 116.7514 +17830, 67.12278, 124.5669 +17831, 66.35003, 126.2649 +17832, 67.96086, 123.9389 +17833, 66.60797, 129.7934 +17834, 70.68833, 138.1275 +17835, 67.46758, 120.3863 +17836, 71.41271, 134.6558 +17837, 67.32752, 127.3763 +17838, 70.63214, 135.4599 +17839, 68.45124, 140.1733 +17840, 64.6863, 122.1215 +17841, 70.21472, 128.4004 +17842, 67.95426, 114.9715 +17843, 70.44048, 113.0864 +17844, 68.92179, 132.3365 +17845, 70.6785, 128.997 +17846, 67.61551, 101.6088 +17847, 66.09501, 128.1073 +17848, 68.55704, 121.8583 +17849, 69.19175, 136.8494 +17850, 68.16405, 119.0371 +17851, 69.0402, 121.7373 +17852, 66.66933, 131.2186 +17853, 69.87747, 133.1686 +17854, 71.59021, 143.2877 +17855, 67.38968, 131.6709 +17856, 68.20687, 122.5181 +17857, 69.68547, 129.6884 +17858, 67.93426, 121.8744 +17859, 67.1179, 119.5904 +17860, 67.15852, 131.0955 +17861, 68.59133, 132.2124 +17862, 69.26014, 136.4103 +17863, 70.07126, 135.873 +17864, 67.0628, 123.2518 +17865, 69.13139, 133.561 +17866, 68.40603, 150.925 +17867, 69.7404, 134.901 +17868, 69.49899, 145.542 +17869, 66.14494, 141.4612 +17870, 67.79179, 122.9394 +17871, 66.74223, 123.4556 +17872, 66.63048, 110.9128 +17873, 68.4112, 120.4405 +17874, 69.37198, 129.1054 +17875, 65.74819, 109.5126 +17876, 66.01136, 128.2502 +17877, 67.90718, 125.0989 +17878, 67.16599, 139.2742 +17879, 66.48646, 114.6859 +17880, 65.71394, 130.992 +17881, 68.79098, 141.218 +17882, 67.99196, 133.9622 +17883, 66.5631, 127.67 +17884, 70.817, 125.1695 +17885, 66.64471, 129.4135 +17886, 67.40685, 150.7738 +17887, 66.17396, 103.0751 +17888, 67.97678, 129.4215 +17889, 68.48737, 128.1923 +17890, 69.52669, 154.935 +17891, 67.68157, 119.2703 +17892, 65.55334, 103.3069 +17893, 66.66098, 113.6555 +17894, 66.04091, 134.5409 +17895, 68.13648, 130.8127 +17896, 68.13583, 120.3052 +17897, 67.14269, 123.0069 +17898, 66.04267, 110.8981 +17899, 69.08156, 150.8598 +17900, 66.61972, 112.7862 +17901, 66.93529, 111.1 +17902, 67.35236, 125.911 +17903, 68.51651, 131.9403 +17904, 64.4288, 113.6686 +17905, 67.61939, 135.8584 +17906, 67.13547, 136.8187 +17907, 66.36896, 128.5891 +17908, 68.5461, 121.3929 +17909, 69.13348, 118.3683 +17910, 68.62844, 117.1061 +17911, 65.0907, 107.1077 +17912, 66.98252, 104.5822 +17913, 68.60319, 137.7396 +17914, 71.20318, 127.5626 +17915, 67.03676, 116.6844 +17916, 66.41179, 115.3066 +17917, 66.68877, 127.3655 +17918, 69.89705, 138.6612 +17919, 68.88841, 120.0867 +17920, 68.53916, 124.4342 +17921, 68.01568, 126.3073 +17922, 68.68683, 134.0053 +17923, 65.40277, 128.8785 +17924, 68.67509, 124.1615 +17925, 67.4067, 123.0948 +17926, 67.17129, 117.9041 +17927, 65.59616, 115.5202 +17928, 68.67567, 149.735 +17929, 70.48483, 137.5004 +17930, 68.51527, 129.2966 +17931, 67.69421, 127.8233 +17932, 66.9375, 131.2734 +17933, 67.81, 134.0172 +17934, 64.04524, 104.574 +17935, 67.23027, 117.1627 +17936, 72.83977, 134.8802 +17937, 67.47092, 119.7091 +17938, 65.71528, 129.7431 +17939, 71.92649, 124.2943 +17940, 70.05502, 131.3468 +17941, 67.87492, 132.6076 +17942, 66.50503, 119.4857 +17943, 66.91365, 132.5616 +17944, 67.88395, 128.4869 +17945, 66.72951, 140.1601 +17946, 68.50989, 127.1386 +17947, 66.02751, 116.4385 +17948, 65.83821, 133.1072 +17949, 66.03926, 113.465 +17950, 70.46449, 121.1387 +17951, 67.62774, 139.2346 +17952, 67.34629, 139.7259 +17953, 68.28918, 135.4869 +17954, 66.68415, 131.9723 +17955, 67.9826, 140.5009 +17956, 68.07289, 129.6271 +17957, 69.451, 131.9335 +17958, 69.86608, 153.0546 +17959, 68.37755, 135.7714 +17960, 68.6245, 141.193 +17961, 66.61664, 132.7202 +17962, 70.06392, 145.6707 +17963, 69.15142, 118.9946 +17964, 68.98655, 141.885 +17965, 68.9009, 132.7891 +17966, 68.21302, 120.9478 +17967, 66.3911, 120.5331 +17968, 66.83657, 120.8557 +17969, 66.48676, 128.8555 +17970, 67.74059, 124.7659 +17971, 68.18607, 128.0024 +17972, 69.87665, 113.3553 +17973, 67.0486, 122.6413 +17974, 67.27659, 102.4448 +17975, 66.51091, 119.3634 +17976, 68.91221, 131.2366 +17977, 65.68233, 110.3737 +17978, 72.45968, 133.0092 +17979, 68.18543, 130.0549 +17980, 69.14627, 149.4217 +17981, 66.64452, 128.6803 +17982, 69.28048, 141.1256 +17983, 64.94449, 117.1219 +17984, 67.63184, 129.0595 +17985, 69.17876, 118.432 +17986, 68.17164, 119.7833 +17987, 67.87229, 129.1417 +17988, 66.08932, 116.2913 +17989, 68.80233, 130.847 +17990, 67.47177, 124.7299 +17991, 69.04627, 134.744 +17992, 65.53588, 135.9945 +17993, 66.41675, 118.6227 +17994, 70.97724, 143.0605 +17995, 70.31771, 126.9513 +17996, 68.63439, 123.4122 +17997, 66.04782, 128.4055 +17998, 68.97705, 141.9362 +17999, 68.91452, 133.6861 +18000, 67.87146, 107.1111 +18001, 67.37218, 133.1697 +18002, 66.3178, 118.4692 +18003, 66.48568, 117.9041 +18004, 69.2381, 132.462 +18005, 67.2139, 132.6842 +18006, 68.50477, 134.123 +18007, 63.66317, 136.7526 +18008, 66.32945, 110.6483 +18009, 67.10945, 123.3761 +18010, 70.02339, 132.8187 +18011, 66.06018, 115.8997 +18012, 68.59984, 106.3343 +18013, 67.16997, 133.2448 +18014, 68.15961, 126.2497 +18015, 67.9255, 136.4886 +18016, 68.24803, 131.2595 +18017, 68.63838, 126.5846 +18018, 67.30494, 119.9612 +18019, 68.54865, 134.5564 +18020, 68.53894, 133.6246 +18021, 68.78754, 122.2611 +18022, 69.70884, 135.1988 +18023, 65.90638, 125.9987 +18024, 70.37854, 129.9166 +18025, 70.70388, 139.938 +18026, 67.22265, 114.1903 +18027, 69.80605, 131.4128 +18028, 67.97377, 115.0723 +18029, 69.83246, 129.3358 +18030, 69.33122, 127.4932 +18031, 68.67805, 125.6517 +18032, 69.58794, 131.1589 +18033, 68.42502, 124.2701 +18034, 67.69161, 113.9616 +18035, 70.2256, 145.9646 +18036, 70.04402, 139.6768 +18037, 67.95373, 139.5456 +18038, 68.3128, 121.7718 +18039, 68.40937, 122.1585 +18040, 66.4482, 133.4419 +18041, 65.28092, 124.6637 +18042, 68.09486, 128.0449 +18043, 66.70524, 120.472 +18044, 65.41192, 117.5336 +18045, 65.85663, 135.9652 +18046, 70.74685, 149.2883 +18047, 69.57387, 117.9533 +18048, 68.94783, 128.49 +18049, 68.47448, 126.3915 +18050, 71.04807, 152.0604 +18051, 67.63577, 124.4287 +18052, 65.52926, 134.8985 +18053, 66.79635, 119.705 +18054, 67.76397, 141.058 +18055, 64.71368, 120.2188 +18056, 66.01498, 109.751 +18057, 69.09526, 128.5564 +18058, 69.5558, 117.3931 +18059, 70.0715, 137.8603 +18060, 67.86641, 126.4714 +18061, 70.0659, 152.4405 +18062, 68.80896, 115.4877 +18063, 68.08706, 121.7255 +18064, 69.52669, 136.2363 +18065, 67.03169, 119.8095 +18066, 65.28391, 103.4991 +18067, 69.47478, 140.6912 +18068, 66.37838, 118.5934 +18069, 66.31288, 123.2614 +18070, 71.26059, 139.1393 +18071, 64.42409, 127.9856 +18072, 67.46592, 129.3959 +18073, 69.28848, 132.1143 +18074, 69.92655, 121.1621 +18075, 67.78948, 131.155 +18076, 64.45606, 111.9183 +18077, 69.29649, 141.9219 +18078, 67.70022, 118.3203 +18079, 64.05875, 112.507 +18080, 65.87971, 107.3144 +18081, 64.19588, 111.4285 +18082, 67.50863, 124.7257 +18083, 71.16467, 146.5501 +18084, 68.71092, 109.9617 +18085, 67.60347, 138.4381 +18086, 67.1752, 117.9673 +18087, 68.9361, 128.3238 +18088, 71.93971, 145.1521 +18089, 67.45158, 127.374 +18090, 68.4984, 127.2154 +18091, 66.04641, 131.7895 +18092, 69.16729, 135.4433 +18093, 66.9408, 130.642 +18094, 71.99802, 149.8457 +18095, 66.92567, 121.6816 +18096, 68.41449, 120.9509 +18097, 68.01572, 105.1644 +18098, 70.20919, 139.4911 +18099, 67.59821, 124.802 +18100, 71.51942, 129.1836 +18101, 67.61313, 128.6954 +18102, 68.63738, 128.6178 +18103, 65.69314, 105.1192 +18104, 70.04372, 137.0862 +18105, 66.35456, 122.6138 +18106, 67.49569, 139.7088 +18107, 63.92701, 111.9422 +18108, 67.44722, 120.0132 +18109, 69.96202, 100.6786 +18110, 68.80541, 121.0008 +18111, 67.75075, 114.8156 +18112, 69.7042, 126.8603 +18113, 69.64501, 120.8241 +18114, 69.39123, 130.6514 +18115, 68.9035, 134.7614 +18116, 66.30156, 103.3628 +18117, 65.82235, 137.0039 +18118, 66.6285, 122.64 +18119, 65.68185, 126.536 +18120, 70.3089, 143.4456 +18121, 71.60372, 129.4984 +18122, 70.64766, 125.3179 +18123, 69.25148, 137.409 +18124, 67.11941, 134.9583 +18125, 62.681, 113.2199 +18126, 69.29774, 136.554 +18127, 68.59213, 125.7968 +18128, 70.21639, 126.2265 +18129, 69.27237, 126.6931 +18130, 67.47561, 133.393 +18131, 67.10278, 142.9183 +18132, 68.97598, 136.8493 +18133, 68.87987, 135.7244 +18134, 62.51831, 124.7827 +18135, 70.16181, 133.7963 +18136, 70.11142, 129.0453 +18137, 71.00201, 127.2179 +18138, 68.83197, 126.4874 +18139, 65.55569, 113.4283 +18140, 69.18478, 114.7062 +18141, 67.17728, 130.403 +18142, 67.96749, 116.2167 +18143, 63.09629, 109.8718 +18144, 67.81887, 125.685 +18145, 72.54256, 140.8276 +18146, 68.38361, 114.9645 +18147, 66.57869, 127.7382 +18148, 72.07371, 137.6268 +18149, 66.14913, 118.2779 +18150, 68.70572, 113.5148 +18151, 69.16225, 144.8836 +18152, 69.46824, 112.4765 +18153, 66.60941, 100.0013 +18154, 65.79111, 117.3869 +18155, 65.76647, 112.3201 +18156, 67.22625, 132.7827 +18157, 69.2736, 120.489 +18158, 68.47907, 128.7633 +18159, 70.22812, 138.8851 +18160, 66.46453, 125.1114 +18161, 67.97522, 125.1482 +18162, 68.8071, 120.3047 +18163, 68.32443, 118.6195 +18164, 69.47959, 126.1822 +18165, 68.03194, 137.12 +18166, 69.48829, 139.8606 +18167, 69.37585, 112.6907 +18168, 69.23615, 121.2323 +18169, 68.69017, 131.3072 +18170, 71.45863, 139.9082 +18171, 67.39093, 122.1571 +18172, 68.53211, 134.3921 +18173, 70.2828, 127.9534 +18174, 67.65305, 110.9933 +18175, 67.20857, 123.4236 +18176, 66.31937, 106.9169 +18177, 63.79425, 115.0191 +18178, 69.65965, 132.1418 +18179, 68.64995, 128.8615 +18180, 67.3593, 122.2451 +18181, 70.33984, 131.6924 +18182, 67.34878, 118.4924 +18183, 66.86827, 114.3971 +18184, 69.52901, 127.1832 +18185, 68.90152, 147.9446 +18186, 70.01268, 142.4176 +18187, 70.59863, 145.8138 +18188, 68.57766, 141.3239 +18189, 64.83389, 98.21334 +18190, 65.52077, 120.3068 +18191, 64.95625, 119.2154 +18192, 66.30334, 124.0317 +18193, 69.48549, 106.2442 +18194, 69.49559, 132.4523 +18195, 68.81243, 125.2854 +18196, 69.2587, 136.2841 +18197, 67.39374, 134.3775 +18198, 70.86215, 127.6207 +18199, 65.80325, 130.9248 +18200, 64.61694, 130.3277 +18201, 70.18644, 141.1758 +18202, 65.12985, 145.219 +18203, 66.26916, 122.1385 +18204, 67.64688, 135.0033 +18205, 70.90986, 129.1092 +18206, 68.94223, 140.3829 +18207, 69.88886, 113.3361 +18208, 67.5314, 138.2173 +18209, 65.13228, 118.1327 +18210, 68.75247, 126.3602 +18211, 66.64471, 114.0659 +18212, 65.97446, 120.8874 +18213, 68.73431, 130.3753 +18214, 65.67938, 131.3553 +18215, 65.55778, 115.0373 +18216, 67.69354, 127.2255 +18217, 66.82119, 114.3377 +18218, 68.46759, 131.2031 +18219, 68.89698, 134.2954 +18220, 65.08409, 115.3981 +18221, 71.76925, 117.198 +18222, 69.8877, 124.6225 +18223, 64.86973, 126.3919 +18224, 70.09753, 141.5936 +18225, 67.35945, 130.7049 +18226, 68.02039, 144.4665 +18227, 66.73404, 128.6324 +18228, 65.62875, 127.3425 +18229, 65.79502, 116.3517 +18230, 70.61392, 129.3511 +18231, 71.74355, 123.4305 +18232, 67.49866, 131.0747 +18233, 66.33294, 120.6984 +18234, 67.92479, 134.5304 +18235, 68.63009, 131.2724 +18236, 67.10296, 113.8506 +18237, 64.19394, 104.6135 +18238, 70.73008, 125.7546 +18239, 63.13516, 118.8045 +18240, 69.24981, 129.8799 +18241, 64.52242, 119.4434 +18242, 66.36544, 126.2793 +18243, 67.62992, 125.1355 +18244, 67.45805, 123.2317 +18245, 68.97952, 122.3737 +18246, 66.40492, 126.2988 +18247, 68.53298, 131.8284 +18248, 65.28708, 111.5392 +18249, 68.17779, 149.5809 +18250, 68.97437, 120.1771 +18251, 70.55554, 129.7295 +18252, 68.91172, 121.2899 +18253, 68.38275, 127.8957 +18254, 70.31738, 114.6335 +18255, 67.88363, 140.9839 +18256, 67.42592, 98.99675 +18257, 70.05856, 129.2721 +18258, 70.19548, 145.6526 +18259, 66.16502, 104.1451 +18260, 66.37637, 128.7241 +18261, 69.99829, 130.8869 +18262, 68.99134, 146.4337 +18263, 68.94388, 139.6823 +18264, 64.99491, 123.3346 +18265, 69.11084, 125.0166 +18266, 67.93461, 116.0817 +18267, 67.01411, 134.6481 +18268, 65.32575, 141.6096 +18269, 71.45383, 134.6091 +18270, 68.01152, 124.4252 +18271, 64.87885, 112.5545 +18272, 68.14952, 119.4716 +18273, 66.66531, 116.4358 +18274, 68.66471, 123.5617 +18275, 67.38528, 123.4536 +18276, 68.49113, 120.9934 +18277, 66.78587, 110.6601 +18278, 69.2274, 115.8926 +18279, 65.96948, 127.8767 +18280, 66.35522, 121.45 +18281, 68.54128, 131.7424 +18282, 66.11305, 102.6734 +18283, 68.28863, 112.3732 +18284, 67.43632, 121.4337 +18285, 66.10499, 109.3116 +18286, 68.51568, 127.1865 +18287, 67.35712, 122.5386 +18288, 65.67569, 132.4576 +18289, 66.88722, 133.6719 +18290, 65.12152, 121.4696 +18291, 68.6178, 126.8987 +18292, 66.13103, 113.5217 +18293, 70.83591, 137.3996 +18294, 68.90076, 145.7439 +18295, 66.21815, 129.6257 +18296, 68.06749, 133.4515 +18297, 68.34053, 126.9106 +18298, 68.80582, 137.9986 +18299, 67.06065, 116.3153 +18300, 66.06083, 111.4023 +18301, 62.72779, 117.2561 +18302, 71.20406, 125.0336 +18303, 67.21888, 124.9911 +18304, 65.65855, 111.0068 +18305, 68.06644, 125.4116 +18306, 70.10401, 139.2201 +18307, 66.70493, 120.9451 +18308, 67.71756, 131.8942 +18309, 62.67446, 110.0678 +18310, 65.29473, 106.2219 +18311, 67.20517, 119.7847 +18312, 67.29519, 144.4307 +18313, 68.44048, 133.3402 +18314, 70.78181, 146.3325 +18315, 66.39307, 128.1566 +18316, 67.24037, 112.4023 +18317, 69.33963, 140.6288 +18318, 65.37485, 118.4317 +18319, 71.49449, 124.4993 +18320, 70.83151, 133.3373 +18321, 66.24703, 113.0378 +18322, 65.2573, 113.6279 +18323, 65.20991, 125.9694 +18324, 69.1082, 126.4711 +18325, 71.14384, 125.8373 +18326, 66.79003, 128.9918 +18327, 69.31011, 153.4923 +18328, 64.90285, 132.3529 +18329, 65.45378, 114.0868 +18330, 69.28697, 119.7079 +18331, 65.5537, 112.4582 +18332, 69.72966, 137.5734 +18333, 67.05884, 115.0583 +18334, 70.02535, 133.1753 +18335, 71.40333, 143.8659 +18336, 65.19703, 126.4798 +18337, 66.57693, 122.7911 +18338, 69.39658, 134.2674 +18339, 68.44566, 124.6497 +18340, 72.74185, 122.6723 +18341, 67.46665, 134.8106 +18342, 72.08529, 148.5511 +18343, 66.51478, 134.3474 +18344, 68.49908, 137.7086 +18345, 69.51313, 140.3623 +18346, 72.67841, 160.6777 +18347, 64.87969, 117.6116 +18348, 66.81518, 131.5526 +18349, 64.11176, 128.3093 +18350, 70.18729, 127.4651 +18351, 64.37983, 111.3805 +18352, 67.80292, 128.6796 +18353, 69.3405, 129.3896 +18354, 65.40457, 132.2629 +18355, 69.5795, 139.6768 +18356, 66.21928, 113.7115 +18357, 65.52875, 102.465 +18358, 66.81484, 136.6555 +18359, 67.08464, 126.9116 +18360, 66.42219, 133.5132 +18361, 64.69989, 107.3891 +18362, 67.27032, 124.3337 +18363, 66.53975, 113.5752 +18364, 68.78295, 132.6993 +18365, 68.09623, 129.5183 +18366, 65.65343, 108.2289 +18367, 67.29559, 129.9961 +18368, 70.47152, 141.2098 +18369, 68.77322, 139.9161 +18370, 67.3118, 134.2859 +18371, 71.43053, 132.9983 +18372, 69.27809, 137.9838 +18373, 68.6156, 122.2664 +18374, 70.38529, 144.5917 +18375, 68.90408, 113.6984 +18376, 69.956, 137.618 +18377, 69.08083, 126.6975 +18378, 68.58346, 127.6423 +18379, 69.55913, 135.0345 +18380, 67.87572, 131.5021 +18381, 68.04456, 125.3529 +18382, 69.61629, 130.6801 +18383, 67.38283, 126.7602 +18384, 70.06792, 133.7293 +18385, 65.72838, 126.3271 +18386, 68.66827, 120.6609 +18387, 69.23921, 144.166 +18388, 67.60529, 127.6045 +18389, 67.02823, 130.9427 +18390, 68.52986, 130.1434 +18391, 68.06148, 132.0809 +18392, 69.89291, 121.0481 +18393, 69.95674, 127.3249 +18394, 71.36783, 126.4851 +18395, 71.02923, 132.704 +18396, 67.45478, 124.9489 +18397, 65.64995, 111.3464 +18398, 70.54974, 118.2128 +18399, 64.73194, 127.1272 +18400, 68.39661, 126.2186 +18401, 66.75958, 141.6033 +18402, 70.36383, 143.4256 +18403, 68.07707, 121.5943 +18404, 70.95278, 154.5036 +18405, 65.56764, 123.9059 +18406, 69.43223, 106.3676 +18407, 67.31171, 126.8754 +18408, 70.92227, 133.0625 +18409, 68.71388, 121.1249 +18410, 66.50874, 132.745 +18411, 70.26147, 130.0088 +18412, 67.16654, 111.1425 +18413, 70.24561, 120.9162 +18414, 69.63362, 131.7987 +18415, 66.23707, 119.442 +18416, 69.83489, 125.9842 +18417, 68.70037, 130.8307 +18418, 69.63254, 139.143 +18419, 70.99486, 134.7143 +18420, 70.68998, 149.3115 +18421, 69.36635, 123.4528 +18422, 68.13314, 116.9677 +18423, 70.79422, 120.9634 +18424, 66.18385, 97.99029 +18425, 69.42133, 141.0527 +18426, 69.01491, 117.6252 +18427, 67.27059, 124.4138 +18428, 68.88229, 143.9361 +18429, 67.33816, 125.2068 +18430, 68.66516, 142.6448 +18431, 66.22914, 129.1967 +18432, 68.76597, 122.474 +18433, 69.53247, 115.2221 +18434, 71.49026, 142.5817 +18435, 66.50972, 133.654 +18436, 67.81402, 123.1049 +18437, 65.24439, 121.9487 +18438, 66.01804, 100.4529 +18439, 65.48158, 116.1882 +18440, 68.16192, 125.732 +18441, 65.02381, 134.4425 +18442, 66.88569, 130.0115 +18443, 67.39995, 96.39088 +18444, 65.66171, 109.2462 +18445, 67.95512, 127.9877 +18446, 63.62623, 110.8507 +18447, 69.18472, 108.1881 +18448, 66.551, 105.7101 +18449, 69.236, 110.3032 +18450, 69.26426, 117.98 +18451, 65.99389, 122.8317 +18452, 71.73307, 125.3396 +18453, 66.45155, 115.4263 +18454, 66.39266, 136.1279 +18455, 66.81631, 127.1059 +18456, 67.89039, 124.9759 +18457, 67.84615, 121.3787 +18458, 69.36484, 134.7724 +18459, 64.37297, 123.659 +18460, 72.89808, 138.8161 +18461, 66.99569, 116.2376 +18462, 71.71415, 134.3653 +18463, 70.09297, 135.7937 +18464, 68.57037, 144.2014 +18465, 69.00022, 135.0503 +18466, 69.20893, 120.8345 +18467, 69.46547, 133.6304 +18468, 70.79127, 130.4978 +18469, 68.78851, 118.4584 +18470, 67.9302, 135.4705 +18471, 66.4848, 126.2168 +18472, 65.27146, 101.3705 +18473, 65.50771, 98.70684 +18474, 67.43981, 115.5729 +18475, 69.16119, 151.2058 +18476, 67.83732, 115.3943 +18477, 66.49751, 131.5375 +18478, 68.69063, 116.851 +18479, 67.40924, 142.2469 +18480, 68.69726, 128.5186 +18481, 67.12827, 119.2494 +18482, 69.57438, 125.2213 +18483, 70.35553, 127.9276 +18484, 71.02956, 136.2053 +18485, 67.01715, 119.3356 +18486, 71.66632, 140.0392 +18487, 68.14304, 104.2278 +18488, 69.90342, 145.7605 +18489, 68.65728, 118.4992 +18490, 67.86381, 110.3406 +18491, 67.60299, 124.9038 +18492, 68.42162, 143.2337 +18493, 64.29405, 111.3888 +18494, 70.25668, 130.9311 +18495, 66.92782, 117.0246 +18496, 68.13117, 112.2702 +18497, 68.47671, 125.9732 +18498, 70.70443, 130.0618 +18499, 72.47871, 139.4575 +18500, 66.60089, 121.3741 +18501, 69.52894, 128.6671 +18502, 69.51429, 138.8626 +18503, 69.13138, 146.1917 +18504, 66.80915, 128.2992 +18505, 66.95452, 127.1524 +18506, 65.57553, 132.8521 +18507, 66.99722, 122.4956 +18508, 68.06291, 141.5624 +18509, 67.13541, 149.8053 +18510, 68.78744, 140.3871 +18511, 70.39841, 127.7709 +18512, 67.16952, 112.1317 +18513, 67.6426, 125.1871 +18514, 68.62432, 131.5505 +18515, 66.98255, 129.8261 +18516, 71.15912, 143.7729 +18517, 67.55843, 130.0446 +18518, 68.20677, 131.9831 +18519, 66.78195, 129.1513 +18520, 64.70211, 117.9549 +18521, 66.24742, 118.3215 +18522, 67.50724, 111.2721 +18523, 70.38629, 132.532 +18524, 66.2864, 138.8554 +18525, 66.4173, 110.4561 +18526, 67.91435, 120.5977 +18527, 66.42833, 130.4869 +18528, 70.51451, 144.908 +18529, 69.22832, 117.2825 +18530, 67.99826, 122.5487 +18531, 69.65771, 140.1853 +18532, 72.16883, 136.178 +18533, 69.49369, 118.7416 +18534, 64.38605, 113.8126 +18535, 64.55094, 114.6945 +18536, 68.23747, 112.8025 +18537, 68.02698, 117.2349 +18538, 66.43047, 95.71513 +18539, 69.86725, 148.5763 +18540, 66.96093, 111.8249 +18541, 68.82789, 125.2561 +18542, 66.90197, 129.6533 +18543, 67.30931, 126.2076 +18544, 67.52133, 123.9019 +18545, 66.81174, 137.8045 +18546, 65.82295, 120.199 +18547, 71.38764, 144.7086 +18548, 65.35643, 115.5945 +18549, 63.25179, 105.0179 +18550, 65.59107, 122.5182 +18551, 67.78908, 137.9392 +18552, 68.61336, 118.2248 +18553, 66.90249, 117.65 +18554, 70.02504, 139.5716 +18555, 66.22555, 127.3096 +18556, 67.74102, 142.398 +18557, 68.8943, 131.6782 +18558, 69.12125, 133.2563 +18559, 67.44687, 123.1274 +18560, 67.65991, 120.3186 +18561, 70.9585, 131.0829 +18562, 71.92717, 154.1861 +18563, 67.29513, 132.4132 +18564, 63.95244, 124.3648 +18565, 69.83187, 136.9095 +18566, 68.37524, 114.5381 +18567, 67.95803, 144.8281 +18568, 66.57707, 123.9629 +18569, 67.72062, 141.1541 +18570, 63.92725, 106.6814 +18571, 69.46167, 129.6969 +18572, 68.83466, 131.4672 +18573, 65.94714, 127.9311 +18574, 65.75023, 127.4329 +18575, 70.47518, 139.0174 +18576, 64.98932, 115.5069 +18577, 67.41353, 127.8081 +18578, 68.38407, 122.2271 +18579, 70.05637, 143.8614 +18580, 67.06958, 100.1749 +18581, 69.09877, 125.7953 +18582, 65.96505, 110.9834 +18583, 66.57586, 114.8681 +18584, 67.29729, 125.7866 +18585, 71.21423, 139.5315 +18586, 68.14138, 125.3772 +18587, 68.34001, 132.0128 +18588, 65.93383, 132.1972 +18589, 66.30774, 108.1026 +18590, 67.08573, 110.2558 +18591, 67.53056, 117.9915 +18592, 68.0261, 115.7176 +18593, 68.80557, 108.2525 +18594, 67.85261, 124.1566 +18595, 69.57975, 134.4556 +18596, 65.34904, 102.2823 +18597, 66.65974, 100.292 +18598, 70.67149, 141.6346 +18599, 70.13532, 136.6807 +18600, 67.42062, 114.6369 +18601, 69.4708, 114.7699 +18602, 67.6276, 135.9559 +18603, 67.18211, 131.4971 +18604, 64.45811, 125.6963 +18605, 68.95735, 122.046 +18606, 67.64248, 129.1718 +18607, 64.83179, 112.8573 +18608, 69.27039, 129.563 +18609, 66.83193, 117.5062 +18610, 72.23485, 151.5014 +18611, 65.01063, 95.82746 +18612, 68.34214, 126.7129 +18613, 66.62156, 130.1081 +18614, 67.08814, 133.7359 +18615, 69.05202, 128.0624 +18616, 68.23454, 133.8401 +18617, 68.37516, 135.1791 +18618, 67.03833, 138.5621 +18619, 70.80541, 132.8961 +18620, 66.73256, 141.7823 +18621, 65.72028, 108.2124 +18622, 66.41974, 111.5486 +18623, 67.57764, 134.0803 +18624, 69.56328, 129.1637 +18625, 67.62709, 121.1408 +18626, 65.16098, 122.078 +18627, 67.20458, 130.3198 +18628, 69.59194, 127.5957 +18629, 64.89401, 112.6321 +18630, 68.35388, 126.5067 +18631, 65.82881, 124.3733 +18632, 66.1868, 126.2654 +18633, 70.32643, 129.9479 +18634, 64.06977, 116.5794 +18635, 67.1713, 112.1838 +18636, 64.92458, 130.1598 +18637, 67.43431, 133.5765 +18638, 68.82895, 118.8026 +18639, 69.06337, 119.7953 +18640, 69.7271, 129.4766 +18641, 66.43212, 124.0251 +18642, 67.83192, 129.6701 +18643, 65.52728, 119.5522 +18644, 69.47555, 149.9544 +18645, 65.88912, 120.1125 +18646, 70.92408, 140.4445 +18647, 63.47126, 100.7746 +18648, 65.04097, 136.9673 +18649, 67.16204, 130.3048 +18650, 69.37409, 106.5867 +18651, 69.74416, 130.6283 +18652, 68.68581, 135.8803 +18653, 67.24642, 117.1742 +18654, 65.07326, 105.7219 +18655, 67.29306, 124.5546 +18656, 69.81604, 127.0576 +18657, 70.51899, 121.0529 +18658, 66.6253, 131.1694 +18659, 66.89401, 121.1997 +18660, 67.80165, 105.2037 +18661, 67.97818, 130.5677 +18662, 67.01481, 118.6079 +18663, 64.61004, 120.3031 +18664, 66.19053, 108.752 +18665, 68.07234, 123.3461 +18666, 67.97208, 111.8923 +18667, 64.15535, 128.6441 +18668, 69.75831, 120.5173 +18669, 64.32257, 104.5157 +18670, 69.32868, 128.1567 +18671, 71.4743, 152.8868 +18672, 64.42866, 107.8894 +18673, 68.0485, 139.8643 +18674, 68.41135, 124.3541 +18675, 69.90011, 133.7566 +18676, 68.02798, 134.4956 +18677, 71.979, 152.6473 +18678, 67.06678, 114.378 +18679, 67.47195, 143.9362 +18680, 65.75596, 123.9509 +18681, 69.11893, 117.6573 +18682, 69.61776, 128.4215 +18683, 64.42529, 93.4895 +18684, 68.86031, 124.3513 +18685, 71.35262, 149.7034 +18686, 65.26951, 109.6937 +18687, 67.07489, 116.9079 +18688, 67.17127, 131.3436 +18689, 65.73213, 94.24776 +18690, 68.68319, 133.4584 +18691, 69.1054, 105.3497 +18692, 68.04565, 120.0355 +18693, 69.40605, 128.4936 +18694, 71.15081, 154.0204 +18695, 67.57653, 124.0439 +18696, 66.19606, 113.86 +18697, 67.87278, 147.5407 +18698, 65.36336, 139.1989 +18699, 69.80543, 155.6269 +18700, 66.64909, 119.51 +18701, 68.84986, 128.6154 +18702, 69.83458, 135.5907 +18703, 65.32506, 119.5717 +18704, 64.73504, 130.5975 +18705, 63.47841, 100.2383 +18706, 69.27949, 144.9208 +18707, 68.85303, 130.5177 +18708, 66.69499, 106.0517 +18709, 64.29055, 124.4514 +18710, 66.35597, 128.4833 +18711, 69.72637, 122.6604 +18712, 66.76502, 121.0101 +18713, 68.47077, 136.9773 +18714, 71.66733, 157.2045 +18715, 70.31301, 134.2708 +18716, 67.27406, 125.2117 +18717, 69.53611, 153.2106 +18718, 72.7748, 152.2564 +18719, 69.75516, 131.9829 +18720, 69.31731, 113.889 +18721, 67.59655, 113.7564 +18722, 68.80522, 126.4774 +18723, 66.10887, 105.4664 +18724, 66.65045, 116.9397 +18725, 69.55086, 155.5237 +18726, 70.22757, 145.7376 +18727, 68.77158, 129.6204 +18728, 69.14943, 141.3192 +18729, 65.67652, 115.6393 +18730, 68.16672, 107.975 +18731, 67.61212, 123.8621 +18732, 70.24321, 125.2896 +18733, 69.19034, 141.7787 +18734, 68.81631, 131.713 +18735, 66.33019, 114.6571 +18736, 67.42121, 139.7828 +18737, 67.57223, 122.4153 +18738, 64.35103, 132.7265 +18739, 68.57516, 134.564 +18740, 67.05546, 117.4663 +18741, 68.09799, 124.307 +18742, 71.57853, 117.4121 +18743, 70.06625, 149.8354 +18744, 65.68016, 124.5133 +18745, 66.07335, 112.1744 +18746, 67.57426, 104.5494 +18747, 67.15108, 122.4038 +18748, 69.04551, 132.6149 +18749, 69.20252, 145.5692 +18750, 69.71079, 128.8631 +18751, 65.29563, 113.4145 +18752, 63.64036, 120.7483 +18753, 67.44444, 121.6074 +18754, 67.26357, 155.4769 +18755, 69.67211, 150.7134 +18756, 69.49824, 128.3236 +18757, 69.39577, 132.9491 +18758, 69.61772, 128.1457 +18759, 66.95073, 125.8741 +18760, 65.10061, 101.0707 +18761, 70.60484, 133.2398 +18762, 69.8036, 132.7216 +18763, 64.08148, 119.2167 +18764, 71.7491, 132.2534 +18765, 69.86149, 138.9225 +18766, 70.57948, 121.235 +18767, 69.3868, 107.0816 +18768, 73.40755, 129.8191 +18769, 67.11939, 121.4565 +18770, 66.20766, 120.7871 +18771, 68.55431, 121.6152 +18772, 66.19609, 112.1678 +18773, 69.9654, 142.061 +18774, 69.29187, 129.3865 +18775, 67.8538, 114.4474 +18776, 67.96589, 141.6129 +18777, 68.55128, 123.8771 +18778, 68.75419, 123.9171 +18779, 66.55678, 134.4236 +18780, 70.59726, 130.2703 +18781, 67.02605, 119.901 +18782, 67.41396, 116.1679 +18783, 69.19909, 117.1203 +18784, 70.80766, 144.2022 +18785, 67.60947, 110.2511 +18786, 69.04609, 124.0725 +18787, 66.42537, 134.0266 +18788, 67.11748, 107.6576 +18789, 66.28992, 104.2723 +18790, 70.27361, 139.0315 +18791, 67.69712, 129.6555 +18792, 66.85592, 143.7988 +18793, 67.61554, 140.8081 +18794, 70.14128, 137.2464 +18795, 71.05634, 116.9411 +18796, 63.38973, 128.9919 +18797, 71.79649, 132.8951 +18798, 64.87538, 108.4584 +18799, 66.64629, 124.3705 +18800, 66.66731, 122.7419 +18801, 67.36005, 132.1815 +18802, 67.78648, 141.9301 +18803, 67.65562, 122.0912 +18804, 67.99457, 120.7194 +18805, 67.20666, 131.022 +18806, 67.66445, 111.1134 +18807, 70.7897, 124.2387 +18808, 65.60275, 113.6259 +18809, 68.78444, 141.7825 +18810, 69.97289, 154.4117 +18811, 72.88631, 139.0747 +18812, 68.47303, 134.9762 +18813, 66.79608, 136.3316 +18814, 67.30746, 136.4466 +18815, 69.2924, 137.9162 +18816, 68.29249, 140.8264 +18817, 69.01065, 125.7044 +18818, 67.85167, 123.1633 +18819, 66.52291, 119.8779 +18820, 70.28503, 135.5849 +18821, 67.77965, 138.1189 +18822, 67.25897, 117.2646 +18823, 67.54277, 121.0405 +18824, 70.06108, 149.2393 +18825, 69.45781, 134.1714 +18826, 67.635, 116.5934 +18827, 68.97276, 118.5913 +18828, 66.28357, 129.9358 +18829, 69.75152, 104.6822 +18830, 69.41999, 127.9808 +18831, 71.06858, 152.1248 +18832, 68.33582, 139.4499 +18833, 67.11634, 132.4605 +18834, 67.48548, 107.1629 +18835, 65.88513, 120.3014 +18836, 65.8286, 102.3607 +18837, 69.15262, 129.2947 +18838, 67.73971, 132.0791 +18839, 68.31863, 133.1632 +18840, 65.14074, 117.8809 +18841, 66.25327, 120.4461 +18842, 67.28113, 113.3187 +18843, 71.26882, 129.5776 +18844, 67.2513, 122.3783 +18845, 66.43889, 121.4343 +18846, 66.84667, 107.9407 +18847, 69.75759, 140.9194 +18848, 69.0673, 133.6173 +18849, 69.65999, 130.2559 +18850, 68.93677, 125.3045 +18851, 67.15994, 108.8491 +18852, 69.39921, 130.7668 +18853, 68.34672, 135.8604 +18854, 70.51145, 135.0087 +18855, 69.48508, 123.7083 +18856, 66.907, 100.1432 +18857, 68.13199, 121.5932 +18858, 71.29192, 138.1298 +18859, 70.21849, 118.867 +18860, 68.53744, 148.6424 +18861, 68.98262, 118.1685 +18862, 67.2414, 133.1376 +18863, 68.87922, 123.4291 +18864, 70.11356, 135.6634 +18865, 69.76284, 132.2633 +18866, 69.32483, 117.5478 +18867, 68.85358, 112.7226 +18868, 67.51316, 123.8273 +18869, 67.67759, 132.8392 +18870, 68.30186, 140.4737 +18871, 67.81994, 126.1359 +18872, 65.17462, 110.8658 +18873, 67.21931, 131.6292 +18874, 65.70946, 127.0618 +18875, 66.62218, 135.2702 +18876, 70.03963, 148.768 +18877, 69.57779, 139.1555 +18878, 69.06121, 138.5468 +18879, 67.49563, 106.2282 +18880, 64.4891, 95.6685 +18881, 67.33308, 128.5636 +18882, 65.73318, 141.9346 +18883, 66.24559, 139.3832 +18884, 69.54639, 136.7369 +18885, 70.91309, 139.336 +18886, 67.45435, 123.3438 +18887, 66.8128, 131.442 +18888, 66.07655, 128.2468 +18889, 65.48464, 122.1126 +18890, 67.9735, 115.8705 +18891, 68.17934, 128.1162 +18892, 68.75379, 128.5221 +18893, 70.42998, 138.6082 +18894, 67.84405, 122.6771 +18895, 69.84154, 128.9522 +18896, 68.19966, 125.8263 +18897, 68.52427, 126.4684 +18898, 64.93004, 123.5438 +18899, 66.92609, 133.6922 +18900, 69.75065, 126.1361 +18901, 69.8655, 124.4893 +18902, 66.24436, 131.6072 +18903, 66.32189, 135.3703 +18904, 72.84287, 142.1741 +18905, 67.39726, 131.4489 +18906, 65.01832, 115.0837 +18907, 70.59535, 143.0093 +18908, 70.17018, 146.3284 +18909, 67.4578, 136.3524 +18910, 67.26702, 123.5548 +18911, 69.817, 132.1167 +18912, 66.24797, 130.474 +18913, 69.63203, 150.5264 +18914, 67.56315, 138.5557 +18915, 69.21375, 131.5255 +18916, 70.23974, 133.6155 +18917, 68.74692, 140.926 +18918, 70.20609, 126.7617 +18919, 68.20052, 131.4243 +18920, 69.01907, 143.3999 +18921, 67.66947, 128.9828 +18922, 64.07139, 138.8326 +18923, 66.59571, 125.3051 +18924, 64.2154, 109.5273 +18925, 67.32259, 111.9082 +18926, 68.2653, 124.3467 +18927, 69.10479, 142.1923 +18928, 67.26557, 109.9298 +18929, 67.56282, 117.22 +18930, 67.70635, 119.8849 +18931, 68.91809, 119.6725 +18932, 66.75571, 111.1221 +18933, 63.60255, 113.6185 +18934, 67.9549, 132.0406 +18935, 70.12267, 136.86 +18936, 68.52279, 122.0874 +18937, 68.27301, 126.9347 +18938, 68.0335, 132.211 +18939, 63.71782, 112.9014 +18940, 63.27713, 123.3834 +18941, 67.44392, 144.5663 +18942, 70.93268, 124.134 +18943, 64.95846, 124.1922 +18944, 67.82998, 134.4499 +18945, 65.67986, 117.3818 +18946, 67.85729, 106.2393 +18947, 68.64131, 126.2599 +18948, 67.15147, 144.6755 +18949, 68.15486, 128.6466 +18950, 66.76022, 120.5667 +18951, 66.15116, 124.4818 +18952, 70.03411, 135.579 +18953, 63.62972, 123.3694 +18954, 67.99637, 127.8984 +18955, 63.86584, 101.1195 +18956, 69.94454, 133.8068 +18957, 68.33791, 134.2027 +18958, 67.69831, 127.598 +18959, 67.13141, 115.7628 +18960, 68.76137, 114.535 +18961, 65.59809, 123.1285 +18962, 66.31687, 100.5823 +18963, 69.44079, 141.2083 +18964, 69.37313, 132.8006 +18965, 68.42964, 128.6768 +18966, 64.69932, 125.6053 +18967, 69.72645, 98.13857 +18968, 68.41304, 133.712 +18969, 65.35887, 116.9776 +18970, 67.12896, 130.9687 +18971, 66.92088, 127.3274 +18972, 69.29888, 138.2458 +18973, 69.09147, 131.6457 +18974, 67.94608, 128.8156 +18975, 69.76571, 147.9617 +18976, 68.06441, 124.6722 +18977, 67.49538, 148.7456 +18978, 67.11697, 113.3744 +18979, 65.08173, 111.555 +18980, 67.85374, 131.636 +18981, 66.25532, 112.1725 +18982, 70.04843, 139.3738 +18983, 71.20862, 134.4401 +18984, 69.74874, 137.7951 +18985, 71.44554, 136.6001 +18986, 69.94668, 141.4994 +18987, 66.87131, 119.1642 +18988, 69.21473, 128.4229 +18989, 66.74018, 127.9894 +18990, 69.6161, 138.6399 +18991, 70.88611, 107.6722 +18992, 65.62141, 132.3347 +18993, 65.47498, 108.9138 +18994, 66.58238, 121.9442 +18995, 67.40184, 120.102 +18996, 66.54299, 100.2631 +18997, 68.20307, 132.0264 +18998, 68.3355, 129.1787 +18999, 66.84503, 110.5189 +19000, 67.14814, 105.918 +19001, 68.95693, 130.3178 +19002, 67.45968, 135.2663 +19003, 69.73828, 139.1718 +19004, 69.82326, 128.9242 +19005, 69.66234, 118.628 +19006, 74.01942, 124.2312 +19007, 64.87799, 127.1184 +19008, 68.45052, 125.3085 +19009, 69.20931, 138.436 +19010, 68.7274, 128.841 +19011, 67.51895, 110.6973 +19012, 69.2305, 146.7603 +19013, 69.58018, 122.7056 +19014, 67.13026, 123.9607 +19015, 68.74446, 138.4759 +19016, 65.03535, 103.0616 +19017, 67.11675, 135.7574 +19018, 67.28088, 105.8265 +19019, 65.52005, 114.0189 +19020, 68.46225, 126.0038 +19021, 68.29754, 125.6328 +19022, 67.42591, 118.7455 +19023, 67.66937, 142.4494 +19024, 71.81863, 146.9166 +19025, 68.71802, 128.9584 +19026, 66.58401, 122.4293 +19027, 69.3764, 120.9916 +19028, 68.44002, 135.6954 +19029, 64.71921, 122.5415 +19030, 68.52755, 125.3404 +19031, 69.35345, 134.088 +19032, 69.20229, 117.4489 +19033, 67.00578, 120.8698 +19034, 66.89812, 112.9835 +19035, 68.35288, 135.8208 +19036, 67.33573, 118.4924 +19037, 69.82623, 138.6881 +19038, 67.099, 128.0533 +19039, 68.54065, 129.6286 +19040, 71.22829, 128.8353 +19041, 68.5347, 130.156 +19042, 69.8437, 134.747 +19043, 69.37798, 153.3498 +19044, 70.73471, 138.6245 +19045, 68.82335, 133.9317 +19046, 70.17434, 126.2272 +19047, 67.29725, 143.426 +19048, 70.27076, 133.5081 +19049, 67.913, 133.8764 +19050, 69.54137, 134.96 +19051, 68.06886, 124.1629 +19052, 70.52222, 123.9367 +19053, 70.17403, 135.6413 +19054, 68.48377, 132.7352 +19055, 66.5262, 100.3805 +19056, 70.2248, 141.5952 +19057, 64.80255, 110.9322 +19058, 65.99408, 114.0842 +19059, 70.21852, 135.3689 +19060, 64.63526, 127.2722 +19061, 69.50261, 143.5405 +19062, 67.94257, 137.276 +19063, 68.60763, 128.7483 +19064, 69.74468, 130.9538 +19065, 70.29051, 135.602 +19066, 70.17636, 150.8629 +19067, 68.32799, 127.8796 +19068, 67.90664, 123.3323 +19069, 66.83077, 123.6567 +19070, 70.27036, 133.2441 +19071, 67.19055, 127.5741 +19072, 67.9287, 111.3912 +19073, 69.57531, 130.2659 +19074, 64.91246, 141.2716 +19075, 67.24179, 107.9326 +19076, 66.73326, 128.6043 +19077, 66.10658, 124.0844 +19078, 66.89731, 124.2085 +19079, 69.97557, 116.4106 +19080, 70.44049, 139.3889 +19081, 70.11371, 150.7673 +19082, 65.99872, 134.8482 +19083, 69.95658, 144.1677 +19084, 69.63275, 130.0907 +19085, 65.33549, 121.2849 +19086, 64.6652, 121.7053 +19087, 67.6065, 133.8331 +19088, 65.23757, 127.3737 +19089, 68.93639, 127.6957 +19090, 66.24616, 130.9438 +19091, 67.52515, 118.5495 +19092, 68.98651, 114.9093 +19093, 68.84443, 115.5114 +19094, 66.88991, 109.6227 +19095, 67.11375, 128.4311 +19096, 71.00279, 133.4631 +19097, 69.99538, 132.4863 +19098, 67.6521, 132.338 +19099, 66.61694, 121.7505 +19100, 66.12389, 115.82 +19101, 68.05366, 142.0749 +19102, 67.73026, 142.6115 +19103, 66.93791, 120.2927 +19104, 70.17167, 130.967 +19105, 66.34749, 138.2904 +19106, 67.05596, 121.2986 +19107, 71.31904, 138.9588 +19108, 67.6327, 121.2978 +19109, 72.3593, 119.509 +19110, 67.54356, 142.1348 +19111, 70.48939, 129.9018 +19112, 68.43258, 128.8285 +19113, 64.68129, 108.7665 +19114, 68.47919, 134.2212 +19115, 66.57968, 124.5066 +19116, 67.2967, 129.1762 +19117, 67.20175, 121.1701 +19118, 67.02215, 131.1607 +19119, 66.46511, 119.6751 +19120, 71.67442, 139.3237 +19121, 68.5519, 143.9093 +19122, 68.65639, 120.3063 +19123, 66.83653, 103.4506 +19124, 70.04256, 132.8487 +19125, 65.59915, 134.7797 +19126, 67.10442, 135.3821 +19127, 67.77316, 111.1036 +19128, 68.32667, 115.483 +19129, 68.48645, 123.7207 +19130, 67.03686, 116.3024 +19131, 66.9232, 147.3265 +19132, 67.87561, 116.4401 +19133, 67.28113, 130.6107 +19134, 66.50314, 130.9561 +19135, 68.32476, 133.2194 +19136, 70.36394, 144.2233 +19137, 65.14779, 131.3557 +19138, 68.01902, 133.8224 +19139, 68.59083, 122.4374 +19140, 69.04421, 130.8801 +19141, 66.88065, 124.1543 +19142, 67.38799, 139.7979 +19143, 68.35328, 123.317 +19144, 68.15364, 119.5603 +19145, 69.75849, 142.1927 +19146, 65.42662, 119.948 +19147, 67.87629, 125.7474 +19148, 69.75726, 129.0609 +19149, 65.78923, 116.9633 +19150, 67.91269, 120.1518 +19151, 71.07096, 143.0026 +19152, 66.99756, 122.3414 +19153, 67.22561, 120.1531 +19154, 70.72869, 157.3854 +19155, 64.74015, 108.5634 +19156, 69.5375, 135.2244 +19157, 69.09657, 120.9011 +19158, 67.70209, 132.6755 +19159, 68.81677, 124.6396 +19160, 68.74628, 125.283 +19161, 66.57536, 121.695 +19162, 67.1991, 127.4141 +19163, 67.24854, 123.2395 +19164, 67.80506, 124.4279 +19165, 71.97488, 138.2571 +19166, 69.89842, 143.7624 +19167, 64.42791, 112.2905 +19168, 67.95844, 137.1145 +19169, 65.51837, 133.997 +19170, 65.50773, 98.01516 +19171, 64.52474, 113.2789 +19172, 69.0834, 130.9646 +19173, 72.04364, 141.8397 +19174, 65.09556, 108.8232 +19175, 66.52195, 126.2461 +19176, 65.7149, 125.2941 +19177, 67.7545, 133.7375 +19178, 65.18518, 110.504 +19179, 67.74465, 132.5059 +19180, 69.32145, 124.9234 +19181, 70.2348, 134.8146 +19182, 67.37761, 118.2797 +19183, 69.67373, 119.3944 +19184, 65.88791, 107.4635 +19185, 67.85004, 133.4487 +19186, 66.95893, 120.3034 +19187, 68.83336, 124.4998 +19188, 68.49758, 132.5462 +19189, 68.7395, 122.3993 +19190, 65.22748, 127.1413 +19191, 71.98146, 144.7643 +19192, 68.68094, 134.0401 +19193, 67.12628, 118.6035 +19194, 67.01346, 105.0695 +19195, 66.4542, 133.0311 +19196, 67.28432, 134.1482 +19197, 70.71591, 120.961 +19198, 67.63227, 114.1463 +19199, 61.827, 100.9391 +19200, 66.81603, 123.1338 +19201, 66.55006, 115.1238 +19202, 69.87374, 132.9684 +19203, 68.88997, 133.4733 +19204, 63.86542, 88.16618 +19205, 67.473, 134.805 +19206, 69.36134, 136.2666 +19207, 67.66722, 124.3972 +19208, 64.09691, 112.0101 +19209, 70.1153, 140.897 +19210, 68.21237, 120.1281 +19211, 68.31802, 140.4507 +19212, 66.31876, 138.4193 +19213, 65.14711, 117.866 +19214, 68.93837, 152.8404 +19215, 68.30602, 128.9768 +19216, 67.90522, 127.8382 +19217, 68.72415, 131.8936 +19218, 66.15404, 122.0434 +19219, 69.20458, 145.5385 +19220, 68.96299, 119.937 +19221, 67.96634, 121.1045 +19222, 68.39281, 123.3811 +19223, 67.87168, 112.354 +19224, 66.60248, 105.694 +19225, 66.40671, 136.6209 +19226, 71.24337, 119.4742 +19227, 69.85952, 130.22 +19228, 66.3421, 120.0586 +19229, 68.03653, 117.8885 +19230, 68.44799, 125.149 +19231, 66.18949, 100.7205 +19232, 65.35281, 125.1497 +19233, 68.07168, 112.3675 +19234, 69.37941, 117.3375 +19235, 65.60905, 127.3115 +19236, 65.33719, 113.8739 +19237, 67.08696, 113.6991 +19238, 68.91007, 124.7451 +19239, 67.21084, 130.7168 +19240, 70.46212, 127.2606 +19241, 68.49577, 122.6996 +19242, 69.3828, 124.0819 +19243, 66.9424, 99.05577 +19244, 65.05132, 108.3157 +19245, 64.57878, 107.7267 +19246, 70.02453, 106.5897 +19247, 68.64292, 135.4839 +19248, 69.3952, 123.3528 +19249, 64.498, 103.1257 +19250, 68.75748, 129.8778 +19251, 70.5535, 126.2709 +19252, 67.55247, 107.1793 +19253, 72.1117, 137.8252 +19254, 68.24515, 126.9731 +19255, 68.39009, 150.2682 +19256, 66.47685, 125.4514 +19257, 71.38525, 134.2473 +19258, 66.35336, 129.886 +19259, 66.6283, 131.9099 +19260, 68.15306, 131.1771 +19261, 69.33029, 133.502 +19262, 68.60209, 126.7976 +19263, 69.86885, 139.479 +19264, 67.12737, 119.6263 +19265, 69.69019, 122.2988 +19266, 67.82449, 130.1764 +19267, 66.96219, 122.223 +19268, 69.13713, 137.5221 +19269, 66.27125, 125.5452 +19270, 71.64224, 131.3708 +19271, 66.31753, 135.1288 +19272, 71.56528, 154.7509 +19273, 68.35767, 129.9305 +19274, 64.12801, 110.2428 +19275, 70.91483, 147.3623 +19276, 70.31161, 134.3731 +19277, 67.4626, 130.7984 +19278, 70.69375, 153.4537 +19279, 69.64298, 121.5795 +19280, 66.12271, 121.6818 +19281, 68.91139, 134.8144 +19282, 65.59233, 139.8298 +19283, 68.39697, 131.1997 +19284, 71.08749, 127.9353 +19285, 66.69531, 136.8321 +19286, 65.6135, 118.7268 +19287, 67.24761, 114.7405 +19288, 63.98366, 122.5457 +19289, 67.44473, 143.2907 +19290, 69.45442, 142.9678 +19291, 66.65284, 140.9184 +19292, 66.90633, 112.5183 +19293, 67.36174, 132.7616 +19294, 68.85531, 113.9658 +19295, 67.14749, 110.8704 +19296, 68.43251, 127.4271 +19297, 66.76784, 114.9009 +19298, 65.88806, 106.0497 +19299, 70.28666, 139.7015 +19300, 65.73875, 132.1646 +19301, 66.85533, 130.9737 +19302, 67.81668, 119.0647 +19303, 66.13711, 118.1549 +19304, 67.44496, 134.7946 +19305, 70.31339, 135.4947 +19306, 69.67229, 138.3051 +19307, 68.20788, 130.6784 +19308, 69.07866, 135.7628 +19309, 69.2147, 145.863 +19310, 69.03707, 134.3548 +19311, 67.4867, 130.712 +19312, 68.65038, 130.0623 +19313, 68.47651, 117.658 +19314, 66.81897, 125.9835 +19315, 68.62807, 128.3296 +19316, 66.49421, 100.1453 +19317, 69.32902, 117.3836 +19318, 66.80477, 109.5414 +19319, 67.45323, 117.2084 +19320, 66.82436, 118.9075 +19321, 68.44044, 132.5773 +19322, 68.17205, 135.7029 +19323, 65.54081, 120.4393 +19324, 69.87822, 134.6517 +19325, 70.74234, 154.9873 +19326, 69.72666, 142.6482 +19327, 69.32118, 130.9678 +19328, 67.35447, 106.6254 +19329, 71.54135, 121.2208 +19330, 65.76665, 122.1748 +19331, 70.40562, 142.0761 +19332, 66.07982, 104.0078 +19333, 66.23757, 122.995 +19334, 71.08337, 141.4795 +19335, 70.71918, 137.857 +19336, 66.42899, 126.2921 +19337, 69.82743, 119.7982 +19338, 67.2883, 132.4893 +19339, 67.54366, 134.223 +19340, 68.67346, 124.9942 +19341, 69.49291, 136.7762 +19342, 65.18689, 131.8571 +19343, 68.63243, 140.3363 +19344, 65.87434, 123.9921 +19345, 69.72791, 134.6838 +19346, 68.86516, 146.82 +19347, 70.78499, 125.1415 +19348, 71.49315, 139.9804 +19349, 68.72414, 133.7544 +19350, 68.80062, 115.5805 +19351, 70.09019, 125.3692 +19352, 70.95429, 142.1598 +19353, 68.65434, 127.7207 +19354, 65.07993, 103.2811 +19355, 67.8804, 122.2327 +19356, 68.69267, 128.8388 +19357, 66.39305, 109.666 +19358, 68.97105, 121.7352 +19359, 67.51326, 122.2808 +19360, 67.77261, 124.7638 +19361, 70.49746, 131.8233 +19362, 67.34338, 131.4508 +19363, 67.12994, 128.448 +19364, 67.28063, 101.792 +19365, 67.83278, 121.5138 +19366, 66.94744, 111.0788 +19367, 68.83627, 125.1171 +19368, 67.17864, 126.6733 +19369, 67.94058, 129.4379 +19370, 70.92914, 135.2796 +19371, 67.86923, 111.0826 +19372, 68.22707, 137.6088 +19373, 66.86146, 119.7778 +19374, 67.65723, 119.8673 +19375, 68.07379, 98.47485 +19376, 73.59392, 145.5716 +19377, 65.40895, 128.1772 +19378, 67.07607, 142.2548 +19379, 66.89452, 117.4998 +19380, 66.42382, 139.1155 +19381, 71.97374, 130.8526 +19382, 67.96789, 119.0567 +19383, 67.25519, 116.9952 +19384, 65.5737, 103.2335 +19385, 69.84429, 127.3391 +19386, 69.55115, 125.4512 +19387, 66.43305, 126.9671 +19388, 68.85178, 117.5224 +19389, 66.7244, 124.9279 +19390, 68.64607, 126.7906 +19391, 63.70431, 112.5109 +19392, 68.19205, 114.4343 +19393, 67.64495, 120.6396 +19394, 67.69633, 129.9412 +19395, 65.56974, 97.43419 +19396, 70.21936, 137.3578 +19397, 67.42904, 125.3863 +19398, 69.43355, 148.2019 +19399, 67.29278, 129.8179 +19400, 69.10066, 151.9111 +19401, 66.92661, 127.0226 +19402, 66.82918, 117.5375 +19403, 70.36044, 119.1202 +19404, 64.68454, 107.658 +19405, 68.78039, 117.1408 +19406, 66.3356, 132.6665 +19407, 71.05723, 148.1894 +19408, 65.98309, 107.8979 +19409, 66.96438, 142.4074 +19410, 62.66094, 102.5225 +19411, 66.7604, 135.5098 +19412, 69.31698, 133.9394 +19413, 66.1443, 137.1406 +19414, 65.13872, 141.9462 +19415, 68.44832, 152.6479 +19416, 69.10624, 132.7292 +19417, 68.52832, 132.1379 +19418, 68.08132, 123.9994 +19419, 68.86629, 136.1652 +19420, 66.3787, 127.2431 +19421, 67.76213, 150.8899 +19422, 65.99674, 147.9077 +19423, 65.81136, 126.1608 +19424, 67.40505, 131.4322 +19425, 66.83229, 123.1594 +19426, 68.63507, 124.9311 +19427, 62.97683, 96.29756 +19428, 71.24168, 132.8696 +19429, 67.47631, 130.3214 +19430, 68.62495, 130.4401 +19431, 68.42664, 122.2238 +19432, 65.46691, 120.4029 +19433, 68.25073, 125.9581 +19434, 67.4445, 119.4108 +19435, 67.1342, 126.346 +19436, 68.13306, 134.1461 +19437, 65.54906, 141.2074 +19438, 71.2458, 147.3819 +19439, 69.55894, 150.7427 +19440, 67.5101, 121.0396 +19441, 67.63941, 122.4085 +19442, 64.82273, 112.1695 +19443, 69.22052, 132.0336 +19444, 69.92432, 144.2027 +19445, 66.98924, 150.2762 +19446, 68.56214, 132.0495 +19447, 66.77559, 127.3659 +19448, 68.73691, 129.7617 +19449, 66.91012, 122.4668 +19450, 67.17807, 126.9057 +19451, 69.93152, 142.0998 +19452, 69.08901, 139.7904 +19453, 70.19955, 130.4641 +19454, 68.66485, 120.245 +19455, 67.02561, 131.4908 +19456, 64.99279, 125.5052 +19457, 69.62365, 146.1419 +19458, 68.24774, 136.1765 +19459, 66.21311, 113.8111 +19460, 65.83904, 132.5109 +19461, 63.6379, 123.548 +19462, 70.60624, 131.5629 +19463, 68.13407, 146.0477 +19464, 69.39546, 136.2664 +19465, 68.94134, 118.7888 +19466, 67.38692, 130.1127 +19467, 64.89061, 111.4397 +19468, 69.9709, 145.0628 +19469, 68.5498, 143.3518 +19470, 69.27563, 137.7491 +19471, 70.71056, 161.4436 +19472, 66.4149, 112.9923 +19473, 62.50167, 91.57279 +19474, 68.42081, 128.0469 +19475, 71.7836, 127.215 +19476, 66.29355, 121.9691 +19477, 66.41854, 126.7928 +19478, 67.77764, 145.8554 +19479, 67.57821, 100.8997 +19480, 67.89491, 114.1335 +19481, 68.64534, 116.5296 +19482, 69.35841, 134.6133 +19483, 68.6794, 140.9111 +19484, 69.63578, 107.6423 +19485, 69.1889, 141.0582 +19486, 68.96742, 145.8354 +19487, 68.61172, 139.6006 +19488, 67.52548, 120.6988 +19489, 66.15107, 105.9052 +19490, 68.68094, 135.0912 +19491, 66.80899, 103.3739 +19492, 68.9321, 127.5417 +19493, 67.76799, 139.2827 +19494, 66.53111, 125.715 +19495, 68.00506, 134.7767 +19496, 67.04487, 116.2412 +19497, 70.32864, 115.7384 +19498, 70.16821, 137.7695 +19499, 68.70678, 132.4533 +19500, 65.97472, 118.204 +19501, 69.80446, 106.9538 +19502, 66.69743, 126.3104 +19503, 67.64179, 116.9737 +19504, 66.80381, 131.6848 +19505, 72.77441, 143.1369 +19506, 69.28426, 140.4357 +19507, 66.80098, 114.5898 +19508, 69.41988, 144.3342 +19509, 66.9729, 131.5274 +19510, 68.03946, 143.2374 +19511, 69.00818, 123.1109 +19512, 69.2158, 148.4322 +19513, 69.63119, 130.0823 +19514, 70.09088, 145.9827 +19515, 66.70823, 124.4015 +19516, 66.09049, 121.7826 +19517, 67.75741, 126.407 +19518, 65.67362, 133.5732 +19519, 67.23266, 132.217 +19520, 69.99684, 144.2222 +19521, 67.57739, 132.6973 +19522, 65.54885, 120.8402 +19523, 69.4322, 121.8002 +19524, 66.99743, 133.9659 +19525, 67.06971, 130.6626 +19526, 64.51039, 109.5663 +19527, 71.90727, 129.9342 +19528, 66.98211, 119.479 +19529, 68.8868, 136.5011 +19530, 67.69444, 130.4561 +19531, 70.7424, 140.6748 +19532, 69.54554, 145.2172 +19533, 69.14821, 135.2195 +19534, 66.50703, 108.6434 +19535, 70.29309, 127.0521 +19536, 67.9355, 133.4828 +19537, 68.21364, 133.9939 +19538, 68.5144, 128.0894 +19539, 65.42839, 111.4876 +19540, 67.86424, 128.8723 +19541, 63.71868, 96.00666 +19542, 70.61081, 123.8097 +19543, 68.90318, 123.7874 +19544, 70.13475, 128.6143 +19545, 71.46053, 152.5282 +19546, 70.03539, 120.0435 +19547, 68.1379, 137.3988 +19548, 63.85703, 125.0479 +19549, 67.30965, 124.9212 +19550, 68.90615, 139.2283 +19551, 71.64804, 125.3181 +19552, 68.88111, 134.4917 +19553, 69.51423, 134.5854 +19554, 68.18086, 121.5733 +19555, 65.69997, 110.1231 +19556, 68.40463, 126.7027 +19557, 71.07505, 140.2282 +19558, 69.27603, 126.8514 +19559, 68.23265, 121.7072 +19560, 68.58259, 117.5669 +19561, 67.36844, 127.4011 +19562, 68.28441, 122.825 +19563, 69.07799, 130.0466 +19564, 67.21276, 126.4072 +19565, 64.98716, 104.79 +19566, 66.9179, 127.2505 +19567, 67.12818, 130.2357 +19568, 66.10688, 107.0003 +19569, 68.57638, 125.1795 +19570, 63.93057, 112.976 +19571, 69.76564, 139.6668 +19572, 68.41106, 151.9062 +19573, 66.36876, 122.2946 +19574, 70.47793, 129.8903 +19575, 65.4282, 121.4682 +19576, 66.03012, 135.4752 +19577, 68.0989, 130.5315 +19578, 68.65857, 146.6697 +19579, 72.01458, 129.7612 +19580, 68.50725, 123.4456 +19581, 69.22753, 125.3293 +19582, 70.19938, 140.7101 +19583, 67.04063, 124.0582 +19584, 66.98144, 121.0401 +19585, 68.71907, 120.0657 +19586, 69.72849, 144.2993 +19587, 69.09655, 123.9771 +19588, 69.7738, 114.8563 +19589, 67.75308, 130.351 +19590, 67.08285, 122.5291 +19591, 71.31542, 136.2466 +19592, 70.79423, 139.6064 +19593, 68.65088, 120.791 +19594, 70.36812, 127.8744 +19595, 68.9855, 117.1791 +19596, 67.35987, 120.6422 +19597, 70.4786, 146.8413 +19598, 69.13282, 134.3117 +19599, 69.53122, 125.177 +19600, 67.98617, 118.3697 +19601, 67.61576, 135.516 +19602, 69.78926, 147.2761 +19603, 66.81312, 130.7799 +19604, 68.68595, 134.9254 +19605, 68.05575, 116.4879 +19606, 67.0537, 115.5655 +19607, 63.55754, 127.6591 +19608, 68.02524, 131.1121 +19609, 71.55392, 137.254 +19610, 67.92525, 109.364 +19611, 68.30782, 137.5401 +19612, 69.51542, 152.0741 +19613, 67.29902, 120.4122 +19614, 68.95044, 125.9445 +19615, 66.93895, 113.2025 +19616, 68.33849, 111.7251 +19617, 66.99193, 117.526 +19618, 64.8404, 122.1497 +19619, 67.83682, 109.6392 +19620, 69.02802, 119.1542 +19621, 69.41642, 112.3215 +19622, 72.88867, 144.9415 +19623, 66.61994, 120.0592 +19624, 68.41957, 132.3673 +19625, 67.05694, 129.4949 +19626, 64.48443, 128.3386 +19627, 70.56403, 128.5002 +19628, 67.67847, 127.6393 +19629, 68.38258, 132.7334 +19630, 68.18807, 128.7375 +19631, 67.85684, 142.625 +19632, 71.13318, 131.6605 +19633, 65.43111, 121.7387 +19634, 69.13164, 113.8551 +19635, 68.69, 137.9111 +19636, 70.5797, 131.3443 +19637, 68.82262, 116.2803 +19638, 68.39201, 111.0592 +19639, 68.73134, 136.7499 +19640, 63.96774, 105.3882 +19641, 67.70227, 137.468 +19642, 65.38377, 110.8341 +19643, 66.86451, 132.972 +19644, 67.14211, 119.5467 +19645, 64.23474, 137.3847 +19646, 66.66678, 106.7181 +19647, 68.51504, 119.8735 +19648, 65.93028, 115.4797 +19649, 67.37382, 118.0422 +19650, 70.25357, 125.9146 +19651, 70.0309, 136.5168 +19652, 66.34973, 123.1756 +19653, 69.95254, 126.0075 +19654, 67.47996, 129.589 +19655, 68.7086, 121.1474 +19656, 67.00906, 134.2455 +19657, 67.72585, 106.4953 +19658, 71.29286, 141.0486 +19659, 68.51699, 122.1062 +19660, 66.62695, 126.9819 +19661, 67.94829, 126.8774 +19662, 66.89987, 102.8782 +19663, 67.42931, 133.088 +19664, 68.2914, 129.8764 +19665, 65.99699, 100.402 +19666, 70.19978, 129.7827 +19667, 67.57201, 131.9072 +19668, 63.39936, 106.8881 +19669, 69.54182, 136.1776 +19670, 66.19251, 128.8525 +19671, 65.75415, 111.5965 +19672, 67.57701, 130.5393 +19673, 65.91428, 121.6722 +19674, 67.43806, 132.718 +19675, 65.96746, 127.1559 +19676, 67.37888, 114.5618 +19677, 67.09216, 107.9098 +19678, 68.09938, 128.7844 +19679, 68.59888, 116.9653 +19680, 64.6891, 100.6123 +19681, 67.80635, 119.7824 +19682, 68.11201, 145.058 +19683, 69.98685, 114.9373 +19684, 66.68902, 114.2804 +19685, 69.52482, 135.5855 +19686, 65.66648, 129.1953 +19687, 69.21321, 122.4687 +19688, 70.13351, 140.4419 +19689, 62.90053, 128.8516 +19690, 69.52934, 106.595 +19691, 69.16515, 156.2241 +19692, 64.9069, 109.8341 +19693, 65.51072, 115.8503 +19694, 67.2087, 132.4732 +19695, 68.02634, 130.6405 +19696, 68.8114, 134.7657 +19697, 71.76238, 141.3491 +19698, 69.32284, 126.9131 +19699, 68.35675, 129.7181 +19700, 67.63756, 142.1868 +19701, 66.06231, 129.2107 +19702, 70.56364, 133.1328 +19703, 67.95176, 129.1952 +19704, 68.27422, 122.074 +19705, 68.18009, 132.0099 +19706, 71.27518, 138.9276 +19707, 65.61842, 106.7735 +19708, 69.22954, 123.4618 +19709, 66.69893, 121.0699 +19710, 66.66889, 111.8507 +19711, 70.84943, 138.1842 +19712, 70.96035, 142.1775 +19713, 68.33222, 115.3974 +19714, 70.48522, 145.0675 +19715, 66.60999, 111.5677 +19716, 69.34036, 139.2212 +19717, 69.4538, 118.4412 +19718, 68.68119, 115.3372 +19719, 66.77448, 116.9586 +19720, 67.07195, 117.4971 +19721, 68.99913, 125.8425 +19722, 66.34261, 137.5813 +19723, 70.08887, 133.1303 +19724, 69.33453, 122.7998 +19725, 65.27707, 113.6954 +19726, 70.02681, 143.2139 +19727, 68.94689, 132.8988 +19728, 66.65913, 122.1781 +19729, 66.79488, 109.0563 +19730, 67.90679, 111.664 +19731, 67.10869, 122.2714 +19732, 70.27947, 136.6405 +19733, 64.55087, 124.048 +19734, 71.15681, 141.6004 +19735, 68.5655, 123.6268 +19736, 65.48782, 127.7492 +19737, 67.74423, 125.1475 +19738, 66.83599, 136.7083 +19739, 67.95903, 115.2646 +19740, 66.72479, 110.7445 +19741, 70.98626, 143.4517 +19742, 66.92733, 126.7084 +19743, 67.5508, 129.1005 +19744, 65.12646, 113.8691 +19745, 69.52241, 112.2243 +19746, 67.01183, 119.4125 +19747, 68.04173, 118.3399 +19748, 68.01268, 132.8762 +19749, 62.53035, 118.2221 +19750, 70.50733, 125.0036 +19751, 62.05222, 120.4365 +19752, 65.71906, 133.3052 +19753, 67.78391, 127.5209 +19754, 67.33371, 125.0801 +19755, 67.91253, 132.1946 +19756, 67.30735, 132.4663 +19757, 69.08878, 123.8895 +19758, 65.76843, 114.4506 +19759, 71.64487, 135.5309 +19760, 66.25808, 113.4446 +19761, 64.36476, 116.8191 +19762, 68.6548, 142.4832 +19763, 68.95971, 144.5926 +19764, 70.20612, 138.5105 +19765, 70.57061, 147.3327 +19766, 69.44979, 123.2579 +19767, 70.52781, 133.765 +19768, 66.10873, 117.6254 +19769, 69.08755, 133.9543 +19770, 66.78469, 134.3005 +19771, 71.75464, 156.2319 +19772, 69.13771, 134.5773 +19773, 66.37631, 135.2777 +19774, 69.74647, 122.6657 +19775, 68.98829, 130.2543 +19776, 68.13136, 149.3854 +19777, 66.75278, 137.7469 +19778, 69.8914, 129.1302 +19779, 67.96866, 138.8191 +19780, 67.21946, 131.7829 +19781, 68.80103, 130.3331 +19782, 68.8093, 124.482 +19783, 68.65306, 127.3968 +19784, 67.87452, 130.8625 +19785, 68.70597, 122.373 +19786, 67.1432, 123.2538 +19787, 69.18709, 126.7873 +19788, 70.99521, 133.4597 +19789, 67.95264, 132.5607 +19790, 68.91363, 119.3353 +19791, 69.8465, 140.0139 +19792, 66.93742, 135.168 +19793, 70.11408, 124.4536 +19794, 67.60622, 114.6471 +19795, 66.39876, 122.4132 +19796, 69.57104, 133.4373 +19797, 70.09709, 123.9662 +19798, 67.25205, 129.9541 +19799, 71.43798, 155.874 +19800, 69.21724, 123.3436 +19801, 67.56125, 127.1117 +19802, 67.90888, 128.6947 +19803, 69.3568, 121.2005 +19804, 67.50241, 135.2608 +19805, 68.60586, 132.9409 +19806, 68.2366, 129.2684 +19807, 68.56842, 122.7771 +19808, 69.21836, 125.1624 +19809, 67.53883, 126.2731 +19810, 70.67327, 147.01 +19811, 64.2879, 112.1385 +19812, 68.46678, 124.5944 +19813, 66.73882, 131.1966 +19814, 70.55971, 129.4913 +19815, 67.84481, 137.5206 +19816, 67.01079, 114.7508 +19817, 65.99934, 133.4685 +19818, 68.58547, 146.8673 +19819, 68.81542, 125.8746 +19820, 67.93911, 120.2009 +19821, 68.93217, 118.3246 +19822, 69.23922, 143.7294 +19823, 67.79848, 115.8199 +19824, 68.65821, 125.5767 +19825, 71.49199, 161.906 +19826, 65.53287, 111.1526 +19827, 71.32373, 137.6824 +19828, 69.91417, 140.2723 +19829, 66.6972, 121.9527 +19830, 70.85386, 154.6366 +19831, 70.49105, 124.3354 +19832, 66.27006, 138.3716 +19833, 68.42409, 116.2243 +19834, 68.50301, 111.7963 +19835, 68.49217, 124.5766 +19836, 68.09457, 134.955 +19837, 66.31346, 136.7885 +19838, 68.98854, 129.8207 +19839, 67.05772, 126.8982 +19840, 73.192, 135.5029 +19841, 67.57593, 114.2885 +19842, 66.45283, 116.0452 +19843, 66.91061, 140.4039 +19844, 69.70103, 156.9321 +19845, 68.56368, 122.4036 +19846, 68.88525, 121.0687 +19847, 71.81982, 113.7783 +19848, 68.90203, 140.996 +19849, 67.3832, 121.1426 +19850, 66.76526, 113.7805 +19851, 67.09286, 109.4495 +19852, 66.22802, 120.2049 +19853, 68.25939, 123.1291 +19854, 69.60131, 135.8837 +19855, 64.74935, 89.95606 +19856, 69.34369, 126.1819 +19857, 69.9412, 139.8169 +19858, 68.28392, 115.4109 +19859, 69.34393, 140.1904 +19860, 66.55206, 125.5455 +19861, 66.75602, 118.3912 +19862, 66.35767, 111.1497 +19863, 66.73085, 119.8054 +19864, 65.89961, 122.6803 +19865, 67.4191, 143.7547 +19866, 68.24369, 131.5036 +19867, 66.7219, 103.6644 +19868, 70.74214, 130.2358 +19869, 67.20501, 126.207 +19870, 70.21431, 132.2408 +19871, 64.26213, 119.1471 +19872, 67.14367, 97.69037 +19873, 68.72736, 124.143 +19874, 68.55679, 102.8629 +19875, 66.29825, 126.6865 +19876, 68.72175, 133.4487 +19877, 69.87889, 139.1403 +19878, 65.49782, 133.31 +19879, 68.17108, 110.079 +19880, 66.70977, 119.4087 +19881, 65.56874, 125.6166 +19882, 69.49271, 132.6257 +19883, 69.51683, 141.4084 +19884, 66.7906, 143.8571 +19885, 70.21997, 121.1117 +19886, 70.24793, 129.4589 +19887, 67.80678, 141.4006 +19888, 70.97413, 128.1364 +19889, 69.75903, 155.8943 +19890, 69.15573, 139.2332 +19891, 68.27188, 140.4572 +19892, 67.52736, 120.8998 +19893, 68.11677, 131.2058 +19894, 65.96669, 134.5409 +19895, 68.82825, 125.8735 +19896, 67.64802, 128.2415 +19897, 66.56822, 129.7301 +19898, 67.92216, 108.3181 +19899, 70.16196, 114.9037 +19900, 66.40088, 126.6422 +19901, 67.98154, 135.6363 +19902, 64.99081, 116.9649 +19903, 71.5318, 142.0447 +19904, 63.2937, 119.9139 +19905, 67.63379, 150.7738 +19906, 68.18959, 140.7606 +19907, 68.28412, 124.5525 +19908, 66.9256, 136.9907 +19909, 68.68962, 116.8921 +19910, 69.26219, 124.0692 +19911, 69.7399, 137.5653 +19912, 69.78169, 124.2681 +19913, 68.89306, 118.0353 +19914, 65.92005, 129.992 +19915, 69.67499, 114.8889 +19916, 70.18064, 120.8334 +19917, 68.31191, 128.3317 +19918, 69.27083, 118.5856 +19919, 69.94767, 125.403 +19920, 63.84479, 111.7573 +19921, 69.72054, 125.5533 +19922, 69.6911, 117.1674 +19923, 68.25765, 132.8261 +19924, 66.49187, 125.1728 +19925, 66.2833, 121.768 +19926, 69.49919, 123.5578 +19927, 66.78395, 153.494 +19928, 69.53808, 152.2727 +19929, 68.26418, 137.6226 +19930, 70.75474, 138.2314 +19931, 66.34255, 135.4049 +19932, 70.56467, 121.9766 +19933, 67.88689, 142.8679 +19934, 67.40779, 110.0451 +19935, 70.88991, 141.9247 +19936, 68.45421, 122.053 +19937, 72.14473, 138.8158 +19938, 67.65045, 125.5035 +19939, 68.39678, 132.4804 +19940, 72.84591, 136.0289 +19941, 67.78233, 125.8292 +19942, 66.10641, 109.5937 +19943, 70.18598, 127.0676 +19944, 65.30154, 132.5025 +19945, 67.26947, 124.3345 +19946, 70.78309, 151.569 +19947, 65.97508, 132.6737 +19948, 70.00396, 110.0049 +19949, 67.10731, 97.30055 +19950, 67.53817, 121.8995 +19951, 68.50307, 128.1864 +19952, 65.67232, 122.9823 +19953, 66.09352, 127.0341 +19954, 68.5779, 138.1229 +19955, 68.91832, 125.8024 +19956, 66.54757, 118.9779 +19957, 66.30367, 106.1037 +19958, 67.09517, 139.1474 +19959, 67.48033, 133.0521 +19960, 68.6264, 126.1881 +19961, 67.43831, 121.3548 +19962, 66.67599, 122.0323 +19963, 64.52116, 121.3941 +19964, 69.79005, 143.503 +19965, 67.22173, 122.6996 +19966, 66.4933, 115.2943 +19967, 65.26414, 120.4538 +19968, 66.56788, 127.3631 +19969, 65.89813, 121.6184 +19970, 69.70797, 127.6245 +19971, 67.9721, 113.4425 +19972, 65.86077, 98.2528 +19973, 65.02716, 125.143 +19974, 68.48686, 143.42 +19975, 67.99138, 125.5912 +19976, 70.2878, 140.5505 +19977, 67.29468, 123.9692 +19978, 68.26174, 113.2655 +19979, 72.25625, 136.0435 +19980, 65.0702, 119.358 +19981, 71.08894, 135.0485 +19982, 68.25279, 133.0544 +19983, 66.785, 128.2321 +19984, 67.62555, 116.0675 +19985, 63.94658, 121.0392 +19986, 68.94779, 124.4974 +19987, 67.64244, 135.1131 +19988, 68.50966, 138.6605 +19989, 68.9745, 118.8841 +19990, 65.93037, 139.6622 +19991, 68.82556, 139.9606 +19992, 67.93484, 121.858 +19993, 66.37528, 118.5364 +19994, 67.22561, 137.6765 +19995, 68.95225, 127.904 +19996, 65.27908, 117.0884 +19997, 67.65755, 123.9277 +19998, 66.69201, 116.5055 +19999, 65.78102, 104.7543 +20000, 68.07045, 129.6798 +20001, 69, 135.3616 +20002, 69.10487, 126.5316 +20003, 72.13193, 161.0239 +20004, 70.90373, 145.6269 +20005, 67.86807, 122.0075 +20006, 67.43892, 131.4767 +20007, 69.43118, 133.454 +20008, 67.10359, 119.217 +20009, 70.18149, 147.2307 +20010, 67.38918, 139.7066 +20011, 70.45714, 139.7301 +20012, 68.63421, 115.9739 +20013, 65.62218, 136.3392 +20014, 67.06349, 123.1228 +20015, 67.30641, 98.95785 +20016, 65.46606, 106.7027 +20017, 66.53001, 121.2127 +20018, 67.3778, 114.9383 +20019, 69.32271, 115.2415 +20020, 66.7957, 128.4932 +20021, 65.32407, 114.5338 +20022, 66.55935, 121.121 +20023, 66.00505, 126.9795 +20024, 69.59739, 152.8693 +20025, 66.09583, 120.371 +20026, 69.36726, 118.9293 +20027, 72.00809, 144.9995 +20028, 66.88928, 110.721 +20029, 66.40722, 123.5727 +20030, 65.5385, 119.9828 +20031, 69.55926, 138.0278 +20032, 69.81405, 122.6454 +20033, 69.91993, 144.7208 +20034, 70.0879, 122.9645 +20035, 66.23051, 99.104 +20036, 67.61818, 141.2592 +20037, 68.58143, 125.3615 +20038, 68.15695, 126.2308 +20039, 67.512, 126.9866 +20040, 70.76552, 142.9296 +20041, 69.26234, 143.2527 +20042, 68.32817, 132.7759 +20043, 69.51257, 113.2856 +20044, 70.02706, 129.0559 +20045, 66.82483, 115.5469 +20046, 69.03162, 142.6512 +20047, 67.60125, 125.5298 +20048, 69.25415, 127.9935 +20049, 68.10161, 115.5621 +20050, 67.65047, 123.7327 +20051, 70.96123, 136.3127 +20052, 68.41146, 131.7994 +20053, 67.37012, 109.7773 +20054, 66.75139, 123.746 +20055, 67.13334, 121.373 +20056, 67.77926, 110.8057 +20057, 66.97201, 112.4094 +20058, 69.62951, 130.6875 +20059, 67.00845, 122.5204 +20060, 65.84782, 110.4676 +20061, 68.74982, 137.4344 +20062, 63.46219, 131.6278 +20063, 68.28298, 121.9196 +20064, 69.08611, 128.7246 +20065, 67.51138, 126.3069 +20066, 67.91991, 122.2827 +20067, 70.05535, 142.0311 +20068, 67.11741, 111.0611 +20069, 68.90664, 119.2548 +20070, 67.97481, 124.2253 +20071, 69.82979, 149.1322 +20072, 68.87782, 132.1464 +20073, 68.62969, 131.2994 +20074, 68.27637, 148.0963 +20075, 67.85369, 120.7737 +20076, 67.06235, 133.1606 +20077, 70.25943, 134.5582 +20078, 69.18391, 131.2755 +20079, 69.92206, 129.2742 +20080, 70.78492, 146.6769 +20081, 70.76045, 134.0286 +20082, 70.82053, 141.0171 +20083, 67.72934, 124.2418 +20084, 67.43639, 129.3814 +20085, 64.30312, 99.33579 +20086, 64.88648, 113.0468 +20087, 63.01244, 101.7311 +20088, 67.53395, 144.4339 +20089, 64.22026, 127.7241 +20090, 68.28249, 116.6627 +20091, 70.01457, 121.0093 +20092, 65.91743, 138.7636 +20093, 67.71394, 125.1313 +20094, 66.88127, 124.8587 +20095, 69.52967, 131.1727 +20096, 67.75601, 135.348 +20097, 69.49112, 154.7671 +20098, 70.22138, 141.0964 +20099, 67.96935, 127.4981 +20100, 68.11017, 128.5156 +20101, 67.92721, 127.1976 +20102, 66.16473, 127.8607 +20103, 69.99519, 143.375 +20104, 71.32358, 121.5075 +20105, 66.49822, 113.8888 +20106, 70.42992, 146.1728 +20107, 68.25325, 136.8917 +20108, 69.59837, 135.2368 +20109, 67.38237, 106.1247 +20110, 69.63917, 135.771 +20111, 67.21378, 112.4521 +20112, 65.34452, 111.6073 +20113, 68.45655, 148.5671 +20114, 68.20121, 137.8471 +20115, 68.83192, 132.2195 +20116, 67.9535, 149.5604 +20117, 67.56446, 148.7404 +20118, 71.56432, 139.6887 +20119, 68.20903, 117.3667 +20120, 67.06256, 135.0763 +20121, 68.82025, 126.8315 +20122, 71.58552, 134.0719 +20123, 70.89583, 103.5093 +20124, 69.64793, 131.3787 +20125, 66.45609, 123.3787 +20126, 69.56363, 141.0351 +20127, 69.23708, 133.7008 +20128, 65.9631, 121.1477 +20129, 68.3926, 118.928 +20130, 70.81159, 143.5666 +20131, 70.25802, 126.5308 +20132, 68.9312, 144.6893 +20133, 66.2989, 110.7134 +20134, 72.15283, 146.939 +20135, 68.20211, 109.0779 +20136, 69.1044, 140.5917 +20137, 67.85693, 134.4135 +20138, 67.39485, 118.5645 +20139, 69.13842, 118.8077 +20140, 66.3523, 150.3613 +20141, 71.42226, 121.618 +20142, 72.04165, 150.4715 +20143, 71.05928, 134.4648 +20144, 68.92866, 140.0844 +20145, 66.87497, 131.2338 +20146, 66.36569, 112.5793 +20147, 68.14086, 119.4189 +20148, 66.96983, 123.9473 +20149, 67.54357, 116.4046 +20150, 70.77658, 136.8102 +20151, 68.23718, 118.8886 +20152, 65.53862, 113.2725 +20153, 70.74761, 129.527 +20154, 67.55223, 124.4289 +20155, 70.84812, 150.4496 +20156, 64.4822, 134.1656 +20157, 67.42974, 122.2538 +20158, 68.7509, 119.9506 +20159, 67.83374, 134.5717 +20160, 63.90073, 116.8635 +20161, 70.12934, 134.9922 +20162, 66.37869, 100.5167 +20163, 68.9421, 118.0776 +20164, 70.85312, 134.9686 +20165, 64.83967, 117.0881 +20166, 67.11542, 128.8033 +20167, 68.74812, 134.275 +20168, 67.68923, 123.2354 +20169, 66.62519, 110.3765 +20170, 69.52379, 122.3171 +20171, 72.60803, 150.6268 +20172, 66.8619, 129.2457 +20173, 67.23587, 135.0301 +20174, 66.98288, 118.3685 +20175, 68.17128, 116.8477 +20176, 67.3241, 128.0642 +20177, 71.1372, 144.0187 +20178, 71.27594, 123.566 +20179, 68.39965, 117.7892 +20180, 68.89269, 144.723 +20181, 66.61543, 119.0238 +20182, 67.87792, 127.064 +20183, 68.88772, 131.1342 +20184, 65.0809, 118.9592 +20185, 65.78164, 128.0685 +20186, 69.07443, 130.0005 +20187, 67.69871, 127.2036 +20188, 68.07915, 151.4387 +20189, 71.94398, 122.1514 +20190, 70.07901, 134.6456 +20191, 65.88124, 128.5412 +20192, 67.77076, 134.9165 +20193, 72.69153, 141.1027 +20194, 69.03806, 126.5811 +20195, 65.71193, 136.4266 +20196, 66.44909, 127.9841 +20197, 68.37502, 145.2352 +20198, 68.09913, 108.097 +20199, 67.05164, 116.4216 +20200, 69.4034, 136.0425 +20201, 65.90879, 102.6161 +20202, 69.2529, 134.5586 +20203, 68.32439, 134.5378 +20204, 72.56715, 134.0677 +20205, 67.16006, 114.3012 +20206, 69.91344, 139.9068 +20207, 69.25259, 127.9861 +20208, 62.57176, 116.0712 +20209, 68.71931, 130.8788 +20210, 67.1141, 125.1614 +20211, 67.42686, 130.3149 +20212, 64.27619, 109.2928 +20213, 65.97118, 127.5532 +20214, 68.29677, 125.902 +20215, 67.4216, 137.4702 +20216, 68.18813, 119.2532 +20217, 66.22803, 117.0998 +20218, 67.71768, 135.8263 +20219, 69.80841, 122.2657 +20220, 67.72574, 110.1562 +20221, 69.0302, 122.5569 +20222, 66.72956, 96.99228 +20223, 66.46165, 97.49168 +20224, 64.83455, 114.8982 +20225, 65.70127, 112.5822 +20226, 68.87993, 122.4194 +20227, 69.96137, 131.7487 +20228, 65.23797, 114.4665 +20229, 67.01631, 114.5892 +20230, 70.19731, 135.6892 +20231, 66.3049, 114.8127 +20232, 64.12913, 105.3937 +20233, 68.18283, 133.3447 +20234, 67.67028, 135.6944 +20235, 68.87122, 136.7085 +20236, 65.48468, 114.5325 +20237, 67.5644, 116.5703 +20238, 70.59715, 135.872 +20239, 65.17748, 115.0443 +20240, 71.057, 126.792 +20241, 67.06806, 129.769 +20242, 68.01857, 122.0285 +20243, 67.53436, 103.3526 +20244, 68.2649, 140.749 +20245, 68.76502, 116.1648 +20246, 69.56514, 144.1114 +20247, 68.47043, 120.0682 +20248, 66.97456, 139.6484 +20249, 67.78233, 142.2416 +20250, 71.97165, 146.9815 +20251, 67.87652, 134.4355 +20252, 67.37003, 129.7164 +20253, 65.51123, 124.857 +20254, 66.43394, 121.4185 +20255, 68.50863, 118.6061 +20256, 65.99469, 123.818 +20257, 67.65941, 125.8492 +20258, 68.16997, 120.6193 +20259, 68.01948, 117.5951 +20260, 67.1946, 136.9306 +20261, 70.9964, 136.1914 +20262, 71.25473, 125.2789 +20263, 68.45711, 126.4985 +20264, 66.9254, 111.3531 +20265, 66.96343, 129.305 +20266, 68.34578, 141.5014 +20267, 68.59318, 137.2555 +20268, 65.71377, 129.8145 +20269, 70.41312, 124.1318 +20270, 70.03799, 133.8807 +20271, 67.56852, 109.6435 +20272, 71.64191, 134.8014 +20273, 65.92905, 116.835 +20274, 67.36226, 129.5522 +20275, 68.135, 132.4818 +20276, 65.26581, 114.4764 +20277, 68.22857, 97.6209 +20278, 70.04585, 129.0328 +20279, 68.69432, 127.4449 +20280, 70.301, 122.6477 +20281, 67.26421, 130.2722 +20282, 69.85285, 118.5515 +20283, 71.63372, 154.6085 +20284, 67.21655, 131.0217 +20285, 70.02939, 120.2406 +20286, 65.5687, 124.9128 +20287, 65.25174, 112.4398 +20288, 65.929, 114.4281 +20289, 67.14311, 115.7168 +20290, 66.49901, 125.9384 +20291, 70.93967, 125.3897 +20292, 66.52816, 136.1073 +20293, 69.84944, 138.9535 +20294, 65.96939, 139.4453 +20295, 68.40828, 117.9883 +20296, 67.60775, 124.6082 +20297, 70.31889, 126.6473 +20298, 67.2128, 132.4211 +20299, 66.21903, 140.6382 +20300, 70.83652, 142.9636 +20301, 64.87568, 112.136 +20302, 68.41633, 123.2201 +20303, 67.53817, 118.8005 +20304, 68.45528, 143.2071 +20305, 69.47681, 126.8002 +20306, 68.64769, 137.4465 +20307, 68.03199, 127.1805 +20308, 67.08338, 116.2853 +20309, 72.59665, 165.69 +20310, 68.18865, 127.3957 +20311, 66.73669, 130.1419 +20312, 68.34888, 134.0523 +20313, 65.38285, 109.3722 +20314, 70.40366, 123.1378 +20315, 68.0996, 134.1465 +20316, 68.73681, 139.88 +20317, 66.70503, 108.05 +20318, 66.91609, 127.735 +20319, 67.71304, 142.4622 +20320, 67.09454, 118.5795 +20321, 70.10587, 140.6171 +20322, 67.63564, 116.2521 +20323, 69.59775, 114.9682 +20324, 63.31969, 116.6964 +20325, 67.50844, 125.711 +20326, 64.22298, 124.6074 +20327, 68.1793, 126.4246 +20328, 68.55696, 127.6106 +20329, 70.15891, 137.2941 +20330, 68.97198, 129.8513 +20331, 69.88406, 138.7922 +20332, 67.74655, 126.6633 +20333, 68.93411, 142.0475 +20334, 67.07117, 127.948 +20335, 66.84105, 121.3274 +20336, 67.96232, 110.604 +20337, 66.81235, 134.9879 +20338, 67.54297, 137.6693 +20339, 67.11473, 140.6498 +20340, 67.44452, 130.1931 +20341, 67.47722, 121.0267 +20342, 69.4803, 132.4652 +20343, 64.54045, 112.5734 +20344, 67.05092, 156.3107 +20345, 67.46141, 117.9935 +20346, 71.26722, 131.7057 +20347, 68.42653, 124.6422 +20348, 66.41842, 111.3519 +20349, 65.59731, 128.8394 +20350, 70.03197, 137.246 +20351, 67.08672, 135.7636 +20352, 70.89503, 130.5971 +20353, 68.59771, 144.4514 +20354, 71.63118, 153.4787 +20355, 64.39522, 93.13802 +20356, 71.59533, 138.6555 +20357, 70.78851, 147.8683 +20358, 66.42758, 133.9707 +20359, 66.85979, 122.2792 +20360, 67.44995, 110.9694 +20361, 71.7881, 144.1019 +20362, 65.40377, 123.0822 +20363, 68.96921, 135.9892 +20364, 66.02056, 111.7557 +20365, 67.01558, 122.3018 +20366, 65.98015, 132.4379 +20367, 69.99987, 131.8418 +20368, 72.77006, 145.7023 +20369, 69.19937, 128.6703 +20370, 68.33541, 130.0217 +20371, 65.90805, 110.325 +20372, 70.4214, 118.5469 +20373, 64.65961, 126.5912 +20374, 68.52782, 145.3248 +20375, 65.43216, 132.3232 +20376, 68.28139, 120.4382 +20377, 67.97639, 122.7008 +20378, 67.1216, 123.1906 +20379, 68.9888, 130.4923 +20380, 72.31685, 130.7836 +20381, 71.48421, 116.0402 +20382, 68.65529, 131.0603 +20383, 67.11382, 128.0532 +20384, 68.62405, 137.5614 +20385, 67.85068, 138.8061 +20386, 69.48292, 129.8207 +20387, 70.50328, 143.8129 +20388, 64.33619, 113.6534 +20389, 68.29958, 134.9162 +20390, 67.4218, 122.3882 +20391, 67.9999, 118.3824 +20392, 65.63699, 92.23364 +20393, 67.0808, 107.6561 +20394, 68.91211, 118.4631 +20395, 63.59144, 128.4961 +20396, 68.81852, 150.2385 +20397, 65.96684, 139.8666 +20398, 68.01035, 122.6358 +20399, 67.85106, 131.9627 +20400, 71.04479, 120.0601 +20401, 67.7153, 127.9327 +20402, 67.84737, 124.7808 +20403, 67.83905, 112.9329 +20404, 69.74146, 147.4557 +20405, 67.97724, 117.8599 +20406, 71.045, 128.2833 +20407, 66.84059, 127.2334 +20408, 68.48567, 132.5849 +20409, 68.14535, 126.5979 +20410, 65.41341, 114.3991 +20411, 70.53582, 139.0164 +20412, 69.15586, 115.9193 +20413, 66.44247, 117.9539 +20414, 66.25178, 120.6345 +20415, 69.06165, 131.7664 +20416, 67.22249, 125.729 +20417, 66.43324, 129.5693 +20418, 69.95125, 130.8579 +20419, 68.44759, 124.3484 +20420, 70.12447, 138.252 +20421, 69.8081, 119.0553 +20422, 66.66426, 111.126 +20423, 69.07965, 124.0522 +20424, 65.75374, 127.0394 +20425, 67.98129, 133.4278 +20426, 67.91274, 136.145 +20427, 70.14506, 127.6122 +20428, 71.66221, 143.7339 +20429, 67.31462, 126.7645 +20430, 66.85489, 125.1375 +20431, 66.2073, 127.1956 +20432, 67.88187, 127.862 +20433, 69.45561, 122.6111 +20434, 69.68169, 129.665 +20435, 66.81274, 120.6235 +20436, 67.39812, 120.5257 +20437, 68.31286, 127.2671 +20438, 68.85197, 127.0149 +20439, 70.87098, 136.8526 +20440, 69.29233, 138.6572 +20441, 68.53017, 120.753 +20442, 66.20327, 126.655 +20443, 69.44148, 139.7399 +20444, 65.62755, 111.5919 +20445, 70.36911, 144.6446 +20446, 68.25511, 126.5607 +20447, 70.74579, 137.4108 +20448, 69.32344, 129.5371 +20449, 72.37667, 135.5361 +20450, 66.5913, 126.8375 +20451, 68.1977, 108.343 +20452, 67.73534, 132.0269 +20453, 65.65796, 135.0314 +20454, 68.33944, 126.1502 +20455, 67.98774, 126.5783 +20456, 68.54596, 132.9952 +20457, 68.38063, 122.207 +20458, 70.22056, 140.0847 +20459, 70.02586, 143.8558 +20460, 67.93956, 129.5068 +20461, 66.14777, 133.4099 +20462, 70.69657, 133.1874 +20463, 68.46672, 116.0821 +20464, 66.11868, 107.6714 +20465, 68.98878, 119.9309 +20466, 65.43912, 110.8787 +20467, 69.24822, 122.2722 +20468, 66.94932, 119.4308 +20469, 69.8028, 155.9683 +20470, 70.60933, 134.2835 +20471, 64.78426, 96.84397 +20472, 66.84264, 111.5454 +20473, 68.86833, 132.5776 +20474, 66.94365, 122.2372 +20475, 68.80139, 114.8579 +20476, 68.53662, 138.1599 +20477, 67.54398, 115.7562 +20478, 65.80968, 107.5309 +20479, 69.44019, 146.7688 +20480, 72.46054, 139.538 +20481, 67.09188, 119.9537 +20482, 71.46543, 129.3841 +20483, 66.06765, 112.5487 +20484, 70.96886, 145.5672 +20485, 68.75285, 140.7801 +20486, 65.12147, 132.9884 +20487, 69.29005, 137.3932 +20488, 69.67431, 128.0475 +20489, 67.58498, 125.6642 +20490, 63.26666, 109.048 +20491, 66.60384, 138.8578 +20492, 66.83134, 146.1347 +20493, 65.56701, 106.8728 +20494, 69.4336, 141.0332 +20495, 69.83412, 137.6869 +20496, 66.49534, 128.6661 +20497, 69.30191, 136.9649 +20498, 70.37349, 131.559 +20499, 68.28454, 107.5659 +20500, 67.51385, 122.6429 +20501, 67.58383, 117.5512 +20502, 68.68046, 132.6414 +20503, 68.31025, 107.7211 +20504, 66.68274, 117.1056 +20505, 69.13988, 109.5238 +20506, 66.6069, 107.7197 +20507, 67.71554, 117.3417 +20508, 72.5178, 142.1602 +20509, 70.39659, 133.5727 +20510, 65.92367, 110.1202 +20511, 68.63932, 141.4085 +20512, 66.27944, 102.8787 +20513, 68.09404, 107.0729 +20514, 62.77861, 110.8067 +20515, 66.02558, 123.5278 +20516, 69.11022, 122.7845 +20517, 67.14077, 126.2096 +20518, 69.85347, 107.1566 +20519, 63.72249, 101.0392 +20520, 64.66334, 123.9993 +20521, 69.61292, 122.092 +20522, 69.72279, 128.8986 +20523, 67.76397, 134.59 +20524, 66.74961, 140.8048 +20525, 66.67181, 114.3215 +20526, 67.69057, 123.4607 +20527, 68.39115, 124.7738 +20528, 67.31796, 136.8823 +20529, 68.69023, 125.262 +20530, 70.04462, 136.1957 +20531, 70.19356, 148.1844 +20532, 69.12451, 133.6843 +20533, 67.56314, 124.4263 +20534, 67.66596, 122.3849 +20535, 65.98485, 136.0888 +20536, 68.9407, 133.1295 +20537, 72.42506, 136.0244 +20538, 66.60508, 104.5026 +20539, 67.37321, 124.8638 +20540, 64.89494, 119.6409 +20541, 64.73669, 111.0633 +20542, 69.93102, 124.5422 +20543, 70.69335, 152.3325 +20544, 64.91169, 112.489 +20545, 69.69729, 122.2093 +20546, 63.56648, 112.8596 +20547, 67.29212, 142.3005 +20548, 68.3562, 117.0085 +20549, 68.12976, 123.0924 +20550, 68.62582, 115.3394 +20551, 66.8343, 105.8407 +20552, 69.98616, 122.6015 +20553, 67.44953, 130.5904 +20554, 69.67914, 123.558 +20555, 67.13387, 106.9958 +20556, 71.13815, 140.6296 +20557, 69.22959, 142.3174 +20558, 67.48473, 122.8173 +20559, 66.87485, 118.1003 +20560, 70.4596, 130.9488 +20561, 72.97347, 148.319 +20562, 67.16616, 108.2369 +20563, 67.36668, 123.3563 +20564, 68.30287, 117.9635 +20565, 68.08229, 131.5261 +20566, 68.94862, 141.0023 +20567, 68.47186, 145.789 +20568, 66.63803, 120.2544 +20569, 66.27658, 119.9535 +20570, 65.02396, 117.4626 +20571, 71.99598, 129.1844 +20572, 68.04691, 121.2735 +20573, 66.34711, 114.8943 +20574, 63.8229, 115.2754 +20575, 65.95638, 118.4989 +20576, 68.23334, 121.6989 +20577, 69.46635, 123.2046 +20578, 68.44607, 142.2776 +20579, 69.20365, 129.7053 +20580, 65.63555, 100.3371 +20581, 69.41412, 127.8275 +20582, 67.57457, 126.7177 +20583, 69.32559, 147.9203 +20584, 67.15965, 129.7563 +20585, 70.27834, 139.5538 +20586, 69.39938, 121.1538 +20587, 69.78475, 126.5296 +20588, 68.70946, 134.4551 +20589, 67.3998, 121.8096 +20590, 66.39262, 117.1371 +20591, 65.54597, 126.8852 +20592, 70.60879, 147.0102 +20593, 69.12623, 136.913 +20594, 66.72257, 122.5503 +20595, 67.40649, 117.2019 +20596, 66.18815, 121.8368 +20597, 68.62091, 121.9134 +20598, 70.1055, 153.0944 +20599, 65.48309, 132.6901 +20600, 68.80217, 128.7584 +20601, 67.71394, 121.7097 +20602, 66.57756, 128.9506 +20603, 67.61238, 130.8714 +20604, 67.23082, 128.4602 +20605, 67.08114, 117.4463 +20606, 66.53761, 122.2484 +20607, 67.41405, 126.4525 +20608, 67.06676, 131.406 +20609, 60.8062, 113.9145 +20610, 68.97175, 140.1085 +20611, 72.75763, 135.1411 +20612, 66.02447, 110.7159 +20613, 68.71706, 126.0198 +20614, 69.58585, 142.5501 +20615, 68.96375, 144.368 +20616, 68.26381, 140.3248 +20617, 68.53173, 133.5063 +20618, 63.69299, 127.3114 +20619, 67.32224, 144.3122 +20620, 69.87332, 136.2286 +20621, 65.77657, 121.8449 +20622, 67.84042, 129.3201 +20623, 68.02586, 127.7367 +20624, 67.22709, 124.1286 +20625, 70.33705, 113.399 +20626, 64.42061, 119.5736 +20627, 68.62922, 134.0348 +20628, 67.24371, 139.2993 +20629, 67.47488, 128.9315 +20630, 67.65179, 143.8519 +20631, 68.73059, 133.2077 +20632, 69.53168, 141.696 +20633, 67.76596, 142.9992 +20634, 68.6692, 145.841 +20635, 65.39292, 101.1876 +20636, 67.21484, 126.5562 +20637, 67.39797, 126.3908 +20638, 68.43286, 136.4691 +20639, 66.50645, 117.1767 +20640, 65.10771, 114.3875 +20641, 70.25153, 134.4531 +20642, 64.65223, 129.7684 +20643, 68.39572, 137.1362 +20644, 65.58641, 112.8512 +20645, 67.07497, 134.1362 +20646, 70.10614, 127.5408 +20647, 66.44143, 129.3753 +20648, 69.08524, 141.5455 +20649, 66.99606, 134.7843 +20650, 64.84392, 122.3505 +20651, 68.7585, 115.2365 +20652, 67.03556, 143.0013 +20653, 69.10705, 125.3759 +20654, 68.21709, 136.4534 +20655, 67.54954, 99.21333 +20656, 70.05957, 138.7376 +20657, 69.88409, 131.7587 +20658, 69.08434, 130.7379 +20659, 68.81191, 138.1377 +20660, 70.22844, 133.4575 +20661, 63.67519, 114.2171 +20662, 69.40968, 129.3261 +20663, 67.36179, 129.458 +20664, 69.9419, 131.7153 +20665, 68.44902, 122.7104 +20666, 67.76199, 127.8066 +20667, 70.12858, 131.6387 +20668, 67.97947, 133.6018 +20669, 69.83727, 126.7482 +20670, 66.62896, 124.7778 +20671, 69.77866, 128.9596 +20672, 69.32719, 120.7591 +20673, 68.81059, 110.0003 +20674, 68.33355, 123.5156 +20675, 65.4258, 116.0243 +20676, 68.90712, 136.1172 +20677, 65.90871, 100.8179 +20678, 69.61291, 143.8929 +20679, 65.97906, 131.2483 +20680, 64.15687, 121.6986 +20681, 68.2467, 129.0825 +20682, 67.07394, 113.9007 +20683, 66.08619, 123.5496 +20684, 68.43739, 107.3327 +20685, 69.43772, 117.4397 +20686, 68.81411, 140.5039 +20687, 66.23749, 130.4565 +20688, 67.36339, 135.7808 +20689, 68.93254, 121.3642 +20690, 67.86058, 111.123 +20691, 68.66247, 134.825 +20692, 68.4129, 130.3184 +20693, 63.90356, 101.9503 +20694, 69.56018, 118.6513 +20695, 69.81143, 117.3253 +20696, 68.55186, 142.7701 +20697, 66.14069, 111.9785 +20698, 68.79393, 127.0587 +20699, 62.67467, 108.2196 +20700, 68.24157, 126.3228 +20701, 70.13299, 125.7628 +20702, 68.83759, 128.3162 +20703, 69.20668, 126.8811 +20704, 63.01224, 123.2124 +20705, 68.7409, 140.5609 +20706, 66.94988, 121.3932 +20707, 70.13604, 132.7095 +20708, 68.11161, 121.1428 +20709, 66.58893, 118.2131 +20710, 69.98813, 128.2565 +20711, 66.52501, 120.0478 +20712, 65.2536, 142.5526 +20713, 68.66702, 140.5596 +20714, 71.383, 149.9544 +20715, 66.58224, 123.0901 +20716, 66.50775, 122.9845 +20717, 67.13954, 113.5739 +20718, 68.33274, 137.9826 +20719, 66.69458, 110.1558 +20720, 68.21523, 113.6369 +20721, 66.0808, 131.0879 +20722, 69.46013, 116.5407 +20723, 68.46971, 128.2455 +20724, 68.51333, 101.2957 +20725, 69.10467, 126.8762 +20726, 67.91609, 125.1615 +20727, 67.02882, 143.6948 +20728, 66.08997, 111.3684 +20729, 65.02401, 130.3431 +20730, 68.27428, 121.8474 +20731, 67.35413, 129.3491 +20732, 66.36083, 120.4201 +20733, 68.43123, 121.1875 +20734, 67.40001, 121.7106 +20735, 69.1343, 143.8484 +20736, 67.3171, 139.03 +20737, 73.1971, 157.1585 +20738, 68.39262, 110.6509 +20739, 66.29361, 129.1393 +20740, 69.09153, 123.9906 +20741, 68.08869, 121.8243 +20742, 69.84933, 128.1401 +20743, 67.6024, 133.6571 +20744, 69.71303, 149.4977 +20745, 66.84285, 117.0056 +20746, 66.65337, 112.7847 +20747, 68.88409, 124.0698 +20748, 70.70338, 119.2585 +20749, 66.20185, 112.3781 +20750, 66.31546, 119.0874 +20751, 67.41672, 113.6532 +20752, 69.90956, 140.9595 +20753, 67.68745, 109.4462 +20754, 66.35603, 124.8582 +20755, 64.29036, 129.8863 +20756, 69.06878, 146.3358 +20757, 66.89343, 136.7567 +20758, 66.4584, 98.04174 +20759, 68.8269, 130.6512 +20760, 66.65183, 134.0198 +20761, 63.84789, 128.9473 +20762, 65.79543, 119.418 +20763, 66.25942, 94.20537 +20764, 68.35371, 133.6204 +20765, 70.8435, 120.1922 +20766, 66.63549, 116.47 +20767, 69.36633, 142.61 +20768, 67.36309, 112.8032 +20769, 69.12732, 120.6275 +20770, 65.03504, 115.4154 +20771, 69.06645, 119.3467 +20772, 67.35099, 126.3068 +20773, 66.63538, 125.8876 +20774, 66.49659, 127.904 +20775, 69.098, 124.0368 +20776, 68.42363, 149.2454 +20777, 68.12064, 139.9387 +20778, 69.58767, 125.8239 +20779, 66.34056, 125.5225 +20780, 68.89947, 153.7886 +20781, 67.47147, 142.1622 +20782, 68.33028, 135.5338 +20783, 65.90128, 135.2264 +20784, 68.73695, 127.4165 +20785, 67.98409, 122.7703 +20786, 65.63064, 109.6107 +20787, 68.03278, 148.5683 +20788, 68.65828, 124.3302 +20789, 68.63764, 128.7478 +20790, 67.32521, 105.1839 +20791, 64.78784, 126.1355 +20792, 67.67246, 130.4082 +20793, 68.72131, 139.5527 +20794, 67.35886, 107.6427 +20795, 68.01738, 123.0304 +20796, 67.93165, 128.936 +20797, 66.67783, 123.5636 +20798, 68.67803, 136.5982 +20799, 70.36756, 134.6182 +20800, 67.51615, 132.9171 +20801, 66.75303, 132.5747 +20802, 69.96302, 127.5174 +20803, 66.93841, 115.9348 +20804, 68.11271, 130.5024 +20805, 63.94913, 114.6628 +20806, 68.91814, 147.3669 +20807, 67.2232, 114.4928 +20808, 69.55046, 133.7412 +20809, 68.68863, 129.8662 +20810, 70.7747, 138.641 +20811, 69.07808, 148.7933 +20812, 68.33838, 141.2387 +20813, 65.5871, 126.7083 +20814, 69.2935, 139.4127 +20815, 68.89933, 125.6523 +20816, 65.81485, 99.77933 +20817, 67.20659, 125.993 +20818, 66.51348, 127.1042 +20819, 67.55072, 134.551 +20820, 68.23821, 118.6372 +20821, 66.4512, 110.1362 +20822, 68.54449, 141.4482 +20823, 68.6177, 122.9561 +20824, 64.08191, 102.7885 +20825, 65.56492, 123.1351 +20826, 67.21104, 115.6723 +20827, 66.10932, 126.3925 +20828, 68.9513, 143.6607 +20829, 67.49786, 131.6653 +20830, 67.93624, 139.3751 +20831, 65.95214, 130.4147 +20832, 68.68249, 151.5916 +20833, 69.18583, 124.8504 +20834, 70.94061, 142.0348 +20835, 69.47461, 138.1862 +20836, 67.12497, 113.1001 +20837, 68.57401, 125.5023 +20838, 65.39763, 132.4789 +20839, 68.35258, 137.1238 +20840, 67.56785, 136.4769 +20841, 69.52703, 123.4405 +20842, 67.54305, 105.1903 +20843, 63.49236, 114.9085 +20844, 68.98626, 126.71 +20845, 67.55391, 121.5587 +20846, 64.6396, 115.1491 +20847, 69.82904, 136.2695 +20848, 67.85076, 113.2082 +20849, 67.23771, 125.3433 +20850, 69.38105, 139.5524 +20851, 65.41584, 121.8604 +20852, 66.96076, 119.1984 +20853, 65.26585, 117.7246 +20854, 69.31322, 119.5252 +20855, 67.70408, 122.2612 +20856, 68.08721, 129.7701 +20857, 68.26197, 125.9953 +20858, 67.36362, 121.8119 +20859, 68.73217, 131.316 +20860, 69.14267, 111.1968 +20861, 68.56673, 136.4706 +20862, 68.1929, 120.5822 +20863, 69.5696, 121.1881 +20864, 70.8464, 137.1416 +20865, 67.82872, 127.2809 +20866, 67.03478, 108.5558 +20867, 67.81671, 129.7571 +20868, 70.03848, 138.9428 +20869, 66.9821, 127.2445 +20870, 65.79107, 129.8116 +20871, 70.02914, 142.6562 +20872, 69.58224, 132.0934 +20873, 66.87147, 115.1241 +20874, 66.91792, 127.8387 +20875, 67.645, 121.3585 +20876, 68.65355, 119.0566 +20877, 66.91671, 130.2133 +20878, 70.15303, 141.003 +20879, 73.57982, 148.162 +20880, 67.98141, 124.7923 +20881, 71.49609, 145.3407 +20882, 69.85855, 131.7066 +20883, 68.11629, 109.1855 +20884, 70.19549, 136.493 +20885, 68.90094, 103.5978 +20886, 70.63071, 129.0681 +20887, 67.51818, 126.5297 +20888, 66.18712, 136.2942 +20889, 69.09528, 134.2318 +20890, 65.42299, 105.5537 +20891, 65.48038, 115.372 +20892, 66.9465, 113.8431 +20893, 68.70316, 125.9352 +20894, 66.07277, 123.7771 +20895, 69.44961, 110.8748 +20896, 68.81836, 104.8678 +20897, 69.50743, 105.3865 +20898, 67.82486, 118.2755 +20899, 67.69081, 143.7724 +20900, 68.29836, 129.3948 +20901, 68.67553, 120.7367 +20902, 65.8428, 122.3581 +20903, 68.03516, 124.0374 +20904, 65.75933, 145.1502 +20905, 70.38122, 133.3322 +20906, 67.40825, 132.4084 +20907, 69.96042, 126.2582 +20908, 68.28036, 130.5773 +20909, 68.78403, 111.5448 +20910, 67.91698, 128.8497 +20911, 69.37666, 137.7729 +20912, 66.74216, 117.4347 +20913, 68.1985, 135.4972 +20914, 63.58869, 125.2844 +20915, 73.25534, 129.3863 +20916, 67.70295, 110.3234 +20917, 65.97536, 105.0947 +20918, 69.81239, 134.9831 +20919, 68.86872, 123.426 +20920, 72.74547, 148.5568 +20921, 68.30771, 129.105 +20922, 66.76693, 124.0618 +20923, 67.44946, 123.4784 +20924, 69.7046, 141.6202 +20925, 68.97441, 103.9181 +20926, 67.75058, 135.2187 +20927, 66.8731, 124.1057 +20928, 70.45912, 121.7787 +20929, 70.71713, 138.8325 +20930, 65.65535, 118.4649 +20931, 71.45237, 136.8498 +20932, 69.00661, 131.4449 +20933, 64.07452, 139.9216 +20934, 69.47642, 135.5616 +20935, 69.52284, 129.724 +20936, 64.89822, 131.9576 +20937, 70.70905, 134.3203 +20938, 70.19814, 125.1643 +20939, 67.76234, 130.1309 +20940, 67.21866, 135.3954 +20941, 67.54948, 111.8586 +20942, 68.13277, 139.2003 +20943, 68.84252, 126.0857 +20944, 68.97585, 137.8195 +20945, 67.17762, 99.13368 +20946, 67.76576, 131.2841 +20947, 69.05508, 132.9015 +20948, 68.30757, 135.9473 +20949, 67.32683, 123.4861 +20950, 67.29407, 117.8979 +20951, 66.63257, 126.1084 +20952, 66.94794, 107.183 +20953, 68.13987, 133.2584 +20954, 65.21117, 101.1071 +20955, 68.03769, 119.4935 +20956, 67.26932, 128.9103 +20957, 69.77352, 141.6894 +20958, 69.23863, 125.2157 +20959, 68.7891, 114.34 +20960, 67.26289, 117.1026 +20961, 69.29545, 132.6378 +20962, 67.5793, 112.7331 +20963, 67.21365, 108.0763 +20964, 69.62993, 140.0795 +20965, 67.00026, 125.4628 +20966, 67.93443, 122.1726 +20967, 73.47464, 134.996 +20968, 71.5009, 148.2703 +20969, 67.5436, 124.5961 +20970, 71.49304, 128.6835 +20971, 68.1677, 130.5834 +20972, 68.65009, 127.7241 +20973, 66.04619, 112.1905 +20974, 67.31327, 122.8993 +20975, 67.86012, 116.6222 +20976, 69.42007, 128.9863 +20977, 68.38556, 133.6644 +20978, 69.91327, 118.2455 +20979, 68.8823, 138.4001 +20980, 64.05944, 115.5782 +20981, 69.73048, 126.5238 +20982, 68.632, 135.6997 +20983, 69.40445, 137.5303 +20984, 66.00545, 132.9691 +20985, 67.12871, 128.9781 +20986, 67.54768, 115.0198 +20987, 69.18741, 122.9827 +20988, 65.72702, 115.7926 +20989, 67.85686, 110.7137 +20990, 67.32954, 113.4872 +20991, 67.30146, 143.8451 +20992, 66.33349, 107.1243 +20993, 68.22832, 133.2817 +20994, 64.45511, 117.3622 +20995, 67.87195, 149.4365 +20996, 69.92163, 125.4082 +20997, 62.8062, 107.3401 +20998, 69.3377, 151.2393 +20999, 66.60043, 130.1472 +21000, 70.53369, 140.2407 +21001, 68.84104, 122.8631 +21002, 67.22118, 124.7784 +21003, 69.1338, 131.5248 +21004, 70.23848, 138.5036 +21005, 69.10331, 125.7452 +21006, 70.4064, 138.0741 +21007, 66.66478, 139.0241 +21008, 70.33089, 164.4539 +21009, 70.78331, 141.8412 +21010, 66.83722, 121.0509 +21011, 65.8839, 112.9256 +21012, 67.51176, 137.9948 +21013, 71.21095, 156.0802 +21014, 67.16471, 135.2937 +21015, 67.49059, 132.7359 +21016, 69.13583, 118.2087 +21017, 66.44838, 121.7145 +21018, 67.03679, 143.9542 +21019, 66.66855, 116.5589 +21020, 69.36123, 127.5953 +21021, 68.92478, 137.2977 +21022, 69.70613, 144.1729 +21023, 66.70216, 120.8874 +21024, 69.3032, 132.8515 +21025, 68.68207, 121.2207 +21026, 67.12449, 126.3432 +21027, 66.92738, 116.3508 +21028, 71.36236, 142.3522 +21029, 66.8559, 106.8363 +21030, 69.46283, 118.5577 +21031, 66.4827, 114.5936 +21032, 72.45414, 135.0235 +21033, 68.10614, 120.628 +21034, 65.75378, 124.3824 +21035, 67.16782, 130.0399 +21036, 68.57483, 129.4804 +21037, 67.275, 122.2215 +21038, 66.23984, 97.1995 +21039, 72.39041, 155.1414 +21040, 68.82192, 129.0373 +21041, 67.67589, 126.7606 +21042, 66.09883, 118.7709 +21043, 67.79875, 130.1887 +21044, 68.76062, 115.7905 +21045, 68.86156, 136.3079 +21046, 71.20733, 155.2221 +21047, 65.24249, 114.9215 +21048, 67.33131, 112.8186 +21049, 67.52803, 113.459 +21050, 67.1708, 120.6546 +21051, 66.8838, 138.4066 +21052, 67.26462, 117.0708 +21053, 70.94467, 130.2774 +21054, 71.15199, 133.2351 +21055, 69.35701, 156.0959 +21056, 66.91104, 125.0535 +21057, 68.07832, 122.8732 +21058, 65.74579, 110.9296 +21059, 70.64116, 140.3183 +21060, 66.02941, 112.9351 +21061, 68.24326, 128.8593 +21062, 66.30423, 126.4124 +21063, 68.49473, 134.9166 +21064, 67.3683, 121.4269 +21065, 70.00791, 135.6339 +21066, 70.18312, 125.7853 +21067, 66.40708, 117.1961 +21068, 67.79402, 122.4405 +21069, 68.33103, 142.9592 +21070, 67.91136, 134.3773 +21071, 68.75045, 116.0658 +21072, 68.82444, 113.8497 +21073, 70.64267, 152.2908 +21074, 65.18174, 111.8634 +21075, 68.51919, 129.3323 +21076, 67.53344, 124.0318 +21077, 68.04198, 125.4507 +21078, 65.82182, 113.6 +21079, 70.27834, 131.2909 +21080, 65.8653, 128.4877 +21081, 66.70285, 125.9423 +21082, 65.88836, 122.3566 +21083, 72.53781, 142.2356 +21084, 67.31225, 117.6954 +21085, 68.85556, 119.367 +21086, 65.30914, 125.201 +21087, 67.56741, 117.1659 +21088, 72.28651, 124.0883 +21089, 69.366, 126.9316 +21090, 71.66938, 158.0299 +21091, 66.91979, 114.0239 +21092, 67.89303, 145.9459 +21093, 66.50206, 138.815 +21094, 67.5214, 115.5644 +21095, 69.21652, 128.049 +21096, 71.08246, 135.7997 +21097, 65.7973, 113.1585 +21098, 68.3417, 106.9982 +21099, 64.74233, 113.5996 +21100, 68.41921, 112.8349 +21101, 68.91514, 124.1732 +21102, 65.84174, 85.98927 +21103, 68.87032, 131.6613 +21104, 64.44608, 103.521 +21105, 67.63533, 116.7036 +21106, 70.20804, 141.9526 +21107, 70.98603, 139.8524 +21108, 68.13106, 128.396 +21109, 66.16887, 127.3745 +21110, 67.05542, 124.551 +21111, 70.75677, 131.1854 +21112, 70.7158, 133.8729 +21113, 67.69017, 117.9684 +21114, 71.53849, 140.8829 +21115, 68.54535, 126.4914 +21116, 65.67176, 120.1838 +21117, 65.99226, 124.6178 +21118, 68.65845, 138.4224 +21119, 66.32469, 105.8594 +21120, 68.44591, 119.3537 +21121, 69.95113, 141.9147 +21122, 65.77165, 111.8653 +21123, 67.068, 120.3728 +21124, 64.69653, 131.7434 +21125, 69.04278, 126.7 +21126, 67.48211, 130.1113 +21127, 66.90722, 115.2313 +21128, 68.75846, 119.4879 +21129, 67.30096, 114.3547 +21130, 69.55268, 124.3859 +21131, 71.05661, 149.0296 +21132, 69.2149, 138.0464 +21133, 67.82442, 122.1716 +21134, 68.71809, 129.9713 +21135, 67.78082, 124.843 +21136, 64.25649, 96.69205 +21137, 68.77435, 145.0052 +21138, 66.37859, 131.3486 +21139, 69.17309, 126.2065 +21140, 70.34987, 133.2638 +21141, 66.73457, 124.768 +21142, 67.61739, 127.7756 +21143, 67.42499, 136.4474 +21144, 68.36893, 125.469 +21145, 70.41579, 140.6165 +21146, 68.06868, 120.743 +21147, 67.28263, 116.5436 +21148, 67.09562, 129.5261 +21149, 67.12164, 116.9111 +21150, 66.69727, 139.9522 +21151, 67.49634, 117.8126 +21152, 70.01384, 135.0441 +21153, 65.78477, 129.2745 +21154, 69.47803, 159.105 +21155, 66.13543, 122.234 +21156, 68.43099, 146.9206 +21157, 67.75061, 125.6399 +21158, 66.95323, 105.2662 +21159, 69.32421, 129.7352 +21160, 68.63523, 117.0937 +21161, 67.52914, 122.7438 +21162, 68.96422, 126.6954 +21163, 66.61586, 115.7427 +21164, 68.37756, 129.5414 +21165, 71.01311, 127.9603 +21166, 68.8398, 123.6722 +21167, 68.2039, 142.9882 +21168, 68.87387, 122.7388 +21169, 68.56397, 120.7988 +21170, 69.64694, 127.4074 +21171, 68.82478, 141.8906 +21172, 64.48848, 129.7648 +21173, 69.09307, 133.503 +21174, 68.432, 115.0608 +21175, 67.72728, 130.8804 +21176, 68.58961, 133.8262 +21177, 67.23444, 128.1166 +21178, 69.16746, 132.765 +21179, 67.57615, 126.0391 +21180, 65.096, 119.3788 +21181, 65.51027, 107.6904 +21182, 71.15893, 123.3434 +21183, 70.48329, 138.2703 +21184, 68.18618, 140.2804 +21185, 66.94975, 135.623 +21186, 67.48547, 114.2417 +21187, 65.02626, 105.0766 +21188, 68.66772, 128.1246 +21189, 68.76668, 120.2954 +21190, 70.72339, 144.1367 +21191, 68.16494, 142.4759 +21192, 65.74529, 129.1718 +21193, 67.60346, 135.049 +21194, 69.27402, 132.8954 +21195, 68.96879, 122.0169 +21196, 68.43776, 150.6044 +21197, 67.71247, 128.9561 +21198, 71.63304, 138.1379 +21199, 64.46515, 102.4585 +21200, 66.91695, 117.4932 +21201, 65.28324, 124.6847 +21202, 69.80506, 139.8376 +21203, 67.50948, 130.1897 +21204, 68.54457, 133.0212 +21205, 67.50779, 113.7693 +21206, 69.02801, 125.2331 +21207, 67.19638, 128.2747 +21208, 69.38252, 136.381 +21209, 67.07315, 137.2259 +21210, 65.53914, 120.1128 +21211, 69.12113, 136.8986 +21212, 68.12859, 123.5782 +21213, 66.18245, 118.4861 +21214, 68.75005, 125.2406 +21215, 69.66247, 133.9579 +21216, 67.87585, 119.188 +21217, 69.51193, 138.2564 +21218, 68.10429, 117.4216 +21219, 68.41818, 140.0468 +21220, 65.02588, 95.09752 +21221, 68.73364, 119.9769 +21222, 68.46417, 127.8286 +21223, 68.95687, 122.36 +21224, 67.64606, 129.6722 +21225, 67.98046, 111.7482 +21226, 67.52579, 127.943 +21227, 68.10182, 116.2066 +21228, 65.37706, 127.1152 +21229, 66.7445, 120.9335 +21230, 66.27875, 111.7677 +21231, 69.7328, 131.9363 +21232, 67.30255, 119.1448 +21233, 69.02553, 129.4502 +21234, 70.08744, 138.438 +21235, 67.5875, 123.9873 +21236, 68.44123, 135.9688 +21237, 67.97198, 123.3787 +21238, 66.10388, 122.6718 +21239, 66.0128, 116.2522 +21240, 67.45078, 139.0873 +21241, 69.63918, 137.3555 +21242, 70.26322, 128.9824 +21243, 71.18245, 134.1429 +21244, 67.48152, 113.786 +21245, 67.30461, 121.5465 +21246, 68.27851, 128.6151 +21247, 67.93965, 129.5938 +21248, 66.34597, 117.4876 +21249, 66.17643, 134.2907 +21250, 64.65454, 116.1862 +21251, 67.54127, 125.4026 +21252, 68.59123, 122.8707 +21253, 63.19682, 109.5683 +21254, 67.87138, 121.2874 +21255, 69.10296, 143.9699 +21256, 69.35396, 136.2498 +21257, 66.69452, 117.4852 +21258, 68.01196, 111.6817 +21259, 65.03661, 104.7919 +21260, 67.43888, 124.3636 +21261, 66.47035, 128.7613 +21262, 70.20849, 144.0743 +21263, 67.13509, 125.9127 +21264, 64.94556, 129.3952 +21265, 68.59608, 118.1328 +21266, 66.23435, 136.462 +21267, 69.86976, 124.5872 +21268, 67.15711, 121.2002 +21269, 66.2651, 124.1129 +21270, 68.35631, 129.7324 +21271, 71.29633, 135.8907 +21272, 70.11197, 139.2857 +21273, 66.10542, 133.4835 +21274, 69.08371, 133.6883 +21275, 67.40367, 128.5047 +21276, 66.85289, 131.739 +21277, 69.20063, 132.4558 +21278, 70.60672, 124.7653 +21279, 68.53661, 121.9863 +21280, 68.93974, 131.5648 +21281, 67.96975, 127.7058 +21282, 65.23482, 104.5786 +21283, 71.6941, 137.807 +21284, 69.24201, 113.2636 +21285, 67.94013, 140.4541 +21286, 69.61292, 132.7728 +21287, 67.27993, 122.6409 +21288, 66.33297, 135.2301 +21289, 66.12205, 109.5588 +21290, 72.21224, 144.4488 +21291, 68.64486, 134.8144 +21292, 66.69156, 126.1919 +21293, 65.73194, 116.6978 +21294, 68.38632, 138.149 +21295, 71.57464, 153.8989 +21296, 71.70436, 130.4351 +21297, 71.22448, 130.8944 +21298, 69.04649, 116.1818 +21299, 69.24498, 131.2336 +21300, 69.31455, 149.1439 +21301, 67.37766, 116.1292 +21302, 65.85673, 120.8833 +21303, 68.3071, 111.1158 +21304, 62.66611, 102.4978 +21305, 66.11815, 124.0832 +21306, 66.10233, 119.1205 +21307, 70.76474, 134.5527 +21308, 67.3541, 126.4415 +21309, 67.29001, 115.4747 +21310, 68.9878, 136.8897 +21311, 67.50241, 129.6194 +21312, 67.80553, 131.8187 +21313, 70.86344, 143.7688 +21314, 66.88387, 134.1093 +21315, 69.60302, 114.8928 +21316, 65.8415, 109.0991 +21317, 68.05408, 140.0282 +21318, 67.79184, 130.6684 +21319, 66.63211, 130.5872 +21320, 68.05862, 130.8255 +21321, 66.37615, 122.9051 +21322, 66.6771, 106.3209 +21323, 63.97165, 125.9937 +21324, 69.12251, 146.0978 +21325, 68.28209, 134.7229 +21326, 68.12163, 149.2238 +21327, 66.18678, 118.8765 +21328, 67.49155, 121.369 +21329, 70.23978, 127.3437 +21330, 69.18802, 119.5174 +21331, 66.98707, 115.3673 +21332, 71.11033, 145.6761 +21333, 68.61714, 128.542 +21334, 66.8577, 127.9222 +21335, 67.07586, 138.2211 +21336, 63.93118, 111.9108 +21337, 65.85939, 113.125 +21338, 69.44418, 139.1515 +21339, 67.8368, 129.6571 +21340, 64.76778, 123.182 +21341, 66.2066, 113.314 +21342, 67.79536, 131.6799 +21343, 72.01784, 124.9024 +21344, 65.20628, 115.5842 +21345, 67.38543, 127.1064 +21346, 66.56993, 115.3937 +21347, 66.03326, 108.599 +21348, 68.54084, 122.4814 +21349, 66.75178, 123.5222 +21350, 71.83647, 140.7706 +21351, 63.58595, 131.2403 +21352, 67.86356, 125.8127 +21353, 69.18172, 135.9835 +21354, 70.22442, 129.4703 +21355, 70.26193, 126.4545 +21356, 68.25391, 131.4638 +21357, 67.64774, 133.374 +21358, 67.60438, 113.665 +21359, 64.18161, 92.72194 +21360, 69.07121, 133.7058 +21361, 67.16346, 119.9669 +21362, 65.77951, 122.1882 +21363, 66.50073, 124.7978 +21364, 63.97477, 113.8485 +21365, 67.69537, 103.4807 +21366, 70.51405, 154.9609 +21367, 69.76942, 133.3499 +21368, 70.56116, 142.826 +21369, 68.60348, 115.6884 +21370, 64.8078, 126.7873 +21371, 70.90317, 130.958 +21372, 66.45704, 120.7458 +21373, 69.81243, 134.6215 +21374, 67.93456, 113.5044 +21375, 68.21735, 122.932 +21376, 70.49535, 141.461 +21377, 67.39105, 106.465 +21378, 71.6752, 139.7622 +21379, 68.59578, 147.415 +21380, 67.0862, 115.6875 +21381, 68.16122, 136.504 +21382, 67.98705, 105.9146 +21383, 64.80826, 114.3374 +21384, 68.38232, 142.4635 +21385, 69.73223, 130.6929 +21386, 65.31482, 110.0279 +21387, 67.93911, 117.1572 +21388, 66.28781, 128.8133 +21389, 65.31992, 157.9292 +21390, 67.56335, 120.957 +21391, 69.33362, 127.7738 +21392, 68.05282, 119.9513 +21393, 68.7317, 130.5724 +21394, 66.24459, 131.6161 +21395, 67.13869, 130.7992 +21396, 64.8849, 115.8741 +21397, 67.27717, 128.8991 +21398, 66.586, 116.0707 +21399, 67.12561, 113.2244 +21400, 65.22732, 115.8697 +21401, 67.58676, 132.6108 +21402, 69.53328, 124.1201 +21403, 68.83049, 141.3701 +21404, 68.31099, 116.924 +21405, 68.74387, 124.9707 +21406, 64.0985, 103.2453 +21407, 70.8389, 150.1694 +21408, 68.9783, 130.9676 +21409, 67.48817, 124.8039 +21410, 69.27081, 124.6497 +21411, 67.12082, 119.5077 +21412, 70.77956, 125.8114 +21413, 67.97148, 111.5771 +21414, 72.82909, 149.1342 +21415, 66.00035, 115.6001 +21416, 66.37328, 127.1567 +21417, 67.24395, 128.6992 +21418, 69.45193, 122.1409 +21419, 70.32167, 133.6321 +21420, 64.85287, 124.4417 +21421, 66.82049, 124.4221 +21422, 67.88258, 124.2948 +21423, 68.26595, 121.0339 +21424, 66.40595, 108.3041 +21425, 69.54769, 148.9234 +21426, 68.91851, 117.4566 +21427, 67.1916, 123.127 +21428, 67.33889, 120.5712 +21429, 67.05347, 120.1048 +21430, 66.71262, 124.3153 +21431, 69.98886, 141.4564 +21432, 71.51013, 139.8831 +21433, 73.19268, 150.9736 +21434, 67.79156, 132.7662 +21435, 68.64126, 132.4578 +21436, 66.17287, 133.4576 +21437, 67.35348, 134.5655 +21438, 67.26831, 123.5621 +21439, 66.43498, 113.6441 +21440, 69.66258, 122.2091 +21441, 67.46824, 107.2974 +21442, 71.53982, 140.1055 +21443, 70.50755, 130.405 +21444, 67.39344, 140.9644 +21445, 68.28771, 142.5192 +21446, 70.85948, 143.5364 +21447, 68.2026, 128.7043 +21448, 71.52565, 142.5129 +21449, 67.68578, 122.5681 +21450, 68.77033, 145.575 +21451, 69.69672, 124.4363 +21452, 69.86332, 132.8198 +21453, 68.11448, 130.3112 +21454, 67.44093, 132.8781 +21455, 64.59419, 103.0731 +21456, 66.89966, 119.9647 +21457, 66.46718, 113.4911 +21458, 68.19723, 124.665 +21459, 69.78449, 137.4408 +21460, 66.84378, 117.16 +21461, 67.60705, 117.721 +21462, 69.81536, 130.9669 +21463, 68.71877, 128.5218 +21464, 69.44319, 119.0987 +21465, 66.78997, 124.5261 +21466, 70.36901, 141.0114 +21467, 68.40678, 128.6087 +21468, 66.17464, 115.9334 +21469, 64.05399, 133.0834 +21470, 66.90763, 128.5777 +21471, 66.08072, 103.0628 +21472, 68.68999, 121.2085 +21473, 66.15716, 121.0179 +21474, 68.64629, 122.4392 +21475, 64.94119, 116.4141 +21476, 68.07015, 137.3806 +21477, 64.00869, 118.3034 +21478, 65.53683, 107.9785 +21479, 67.41471, 121.7855 +21480, 65.74584, 121.5395 +21481, 66.18987, 140.962 +21482, 63.73028, 114.8628 +21483, 67.5378, 107.9156 +21484, 68.83259, 123.8887 +21485, 68.60078, 114.8935 +21486, 70.33758, 135.3466 +21487, 68.06319, 122.375 +21488, 67.31084, 134.7184 +21489, 67.93548, 111.8576 +21490, 70.21616, 124.6681 +21491, 70.22715, 126.5091 +21492, 67.41853, 123.4532 +21493, 69.66876, 126.5893 +21494, 66.51862, 131.9422 +21495, 66.56167, 123.7117 +21496, 65.37204, 125.3946 +21497, 71.0227, 140.9263 +21498, 69.76803, 125.9309 +21499, 69.13129, 124.6745 +21500, 70.11223, 142.237 +21501, 66.65293, 122.3701 +21502, 71.50512, 126.6515 +21503, 67.35973, 133.4416 +21504, 67.0525, 125.5655 +21505, 70.82773, 148.3559 +21506, 68.41937, 125.6235 +21507, 68.65019, 123.9353 +21508, 67.9628, 132.746 +21509, 70.56903, 126.337 +21510, 69.24189, 135.4178 +21511, 67.38822, 140.2362 +21512, 63.09263, 104.4273 +21513, 68.73587, 111.0236 +21514, 67.79277, 142.0958 +21515, 68.54986, 136.4451 +21516, 70.1535, 120.8283 +21517, 70.09971, 126.219 +21518, 67.95659, 134.1742 +21519, 69.44167, 121.8278 +21520, 67.44686, 126.7548 +21521, 69.5806, 131.3823 +21522, 69.63943, 138.8988 +21523, 69.95134, 143.1008 +21524, 66.54229, 129.1494 +21525, 65.47078, 129.3234 +21526, 65.98373, 137.8792 +21527, 67.1234, 123.9595 +21528, 65.06387, 105.1229 +21529, 69.55975, 139.0725 +21530, 68.47409, 124.6217 +21531, 69.93312, 139.2227 +21532, 67.5759, 144.2837 +21533, 66.79037, 126.0623 +21534, 69.56945, 134.6805 +21535, 73.00543, 144.8899 +21536, 68.94047, 124.2216 +21537, 66.71029, 114.4104 +21538, 70.56037, 126.6797 +21539, 66.06623, 121.9 +21540, 72.09895, 144.037 +21541, 67.44827, 119.4643 +21542, 68.97642, 135.795 +21543, 69.04275, 113.957 +21544, 68.66189, 137.4046 +21545, 71.18002, 136.655 +21546, 66.66057, 126.3655 +21547, 63.36463, 110.6809 +21548, 69.34799, 125.2128 +21549, 69.77767, 135.8281 +21550, 69.07072, 130.9719 +21551, 68.32296, 118.1762 +21552, 66.55968, 118.5975 +21553, 68.37761, 112.1167 +21554, 65.98221, 115.1319 +21555, 63.25998, 110.1988 +21556, 71.62632, 153.9411 +21557, 66.09519, 98.68208 +21558, 67.48908, 116.7462 +21559, 70.30231, 124.28 +21560, 64.70216, 119.9535 +21561, 64.77568, 101.9952 +21562, 66.64032, 119.5377 +21563, 70.55327, 126.3116 +21564, 67.87381, 126.972 +21565, 65.91455, 113.3049 +21566, 69.77502, 125.1068 +21567, 66.139, 107.6645 +21568, 65.92413, 125.8118 +21569, 69.6475, 131.9709 +21570, 68.14729, 124.0205 +21571, 67.74068, 113.6562 +21572, 68.11275, 106.676 +21573, 68.20793, 113.7575 +21574, 68.37827, 123.0314 +21575, 67.82451, 130.8329 +21576, 67.48875, 111.5242 +21577, 69.68654, 142.2781 +21578, 69.65756, 142.6607 +21579, 70.94824, 134.3418 +21580, 68.7831, 121.5774 +21581, 69.0255, 135.5666 +21582, 68.53275, 151.8248 +21583, 65.24397, 139.6435 +21584, 68.75415, 122.4198 +21585, 66.91508, 118.2568 +21586, 68.90378, 143.5003 +21587, 64.45659, 137.1951 +21588, 69.37774, 133.934 +21589, 69.76118, 106.7714 +21590, 67.73498, 132.2829 +21591, 65.93122, 136.2363 +21592, 72.06156, 145.1228 +21593, 69.92008, 139.7968 +21594, 68.01618, 121.4656 +21595, 70.62601, 146.913 +21596, 65.42178, 112.1659 +21597, 68.50672, 139.005 +21598, 69.48629, 128.6752 +21599, 65.57785, 136.1471 +21600, 67.95425, 122.3756 +21601, 68.9238, 137.9993 +21602, 64.5782, 113.4876 +21603, 69.22296, 137.6336 +21604, 65.8112, 122.3264 +21605, 68.38674, 122.2001 +21606, 68.064, 123.0604 +21607, 71.89949, 144.9726 +21608, 66.75955, 113.9546 +21609, 66.26364, 111.5726 +21610, 69.12286, 121.6069 +21611, 71.05851, 132.4697 +21612, 67.82703, 134.8738 +21613, 66.1189, 130.9344 +21614, 67.76657, 123.0486 +21615, 66.34736, 129.4624 +21616, 69.88206, 132.1693 +21617, 68.8186, 116.2218 +21618, 69.22245, 130.6511 +21619, 69.56448, 149.2076 +21620, 65.74056, 129.3787 +21621, 66.94081, 129.4569 +21622, 66.44573, 128.19 +21623, 68.4432, 137.5434 +21624, 67.98349, 130.0934 +21625, 68.25542, 128.3862 +21626, 67.17137, 115.7127 +21627, 66.57049, 137.5753 +21628, 65.00255, 127.5117 +21629, 68.08759, 132.0304 +21630, 68.04764, 140.0717 +21631, 69.45338, 147.4061 +21632, 67.9968, 110.0948 +21633, 63.71092, 103.5775 +21634, 67.26281, 132.7455 +21635, 66.4024, 117.3694 +21636, 63.39192, 109.587 +21637, 67.72768, 118.9536 +21638, 66.803, 119.5927 +21639, 67.10602, 104.2534 +21640, 67.28255, 128.7274 +21641, 66.92397, 111.4987 +21642, 69.27156, 142.0013 +21643, 69.82977, 150.7596 +21644, 67.13762, 115.8561 +21645, 68.9154, 122.9638 +21646, 68.58518, 118.3007 +21647, 67.44759, 110.2889 +21648, 68.28475, 135.5616 +21649, 66.59309, 133.2853 +21650, 69.66864, 125.674 +21651, 66.48926, 127.8714 +21652, 66.0901, 124.6678 +21653, 68.39518, 128.0957 +21654, 70.80442, 130.4059 +21655, 70.79288, 124.7995 +21656, 66.19153, 144.743 +21657, 69.06036, 115.5577 +21658, 68.21507, 129.3545 +21659, 65.55386, 118.7886 +21660, 68.80277, 116.4346 +21661, 69.1402, 119.6141 +21662, 68.15536, 129.5781 +21663, 68.42978, 134.0208 +21664, 71.79676, 147.6642 +21665, 68.11027, 145.6245 +21666, 64.77343, 138.189 +21667, 68.49853, 114.9544 +21668, 68.55531, 146.7026 +21669, 67.41253, 130.7003 +21670, 71.11461, 153.6546 +21671, 66.74425, 129.3251 +21672, 68.39703, 131.2146 +21673, 69.25426, 139.9834 +21674, 67.91866, 136.0479 +21675, 66.60066, 131.2614 +21676, 67.43294, 126.1017 +21677, 69.11285, 147.8694 +21678, 69.6757, 134.3107 +21679, 68.41421, 146.046 +21680, 65.50774, 100.9124 +21681, 69.76777, 137.657 +21682, 70.67766, 141.3048 +21683, 66.20366, 129.6357 +21684, 65.94018, 100.974 +21685, 71.3988, 129.6586 +21686, 71.26908, 149.5428 +21687, 65.25052, 135.2581 +21688, 70.22019, 129.3704 +21689, 67.46231, 121.088 +21690, 65.38827, 125.245 +21691, 71.06891, 151.2576 +21692, 70.64691, 149.0675 +21693, 65.94902, 125.9638 +21694, 69.02074, 128.0814 +21695, 70.46626, 151.3353 +21696, 68.28099, 121.4549 +21697, 67.90092, 146.1333 +21698, 66.4104, 125.4014 +21699, 68.78832, 128.2448 +21700, 64.64202, 117.7037 +21701, 64.62019, 126.3926 +21702, 68.67167, 106.6081 +21703, 68.10937, 128.4228 +21704, 66.32562, 128.0712 +21705, 68.69826, 126.9703 +21706, 62.48237, 100.3418 +21707, 68.46424, 133.7977 +21708, 65.35569, 125.5137 +21709, 65.85849, 129.4713 +21710, 66.3082, 126.7998 +21711, 65.70911, 113.7976 +21712, 65.6121, 131.8419 +21713, 67.63331, 135.7273 +21714, 66.74792, 123.7179 +21715, 70.65296, 157.9704 +21716, 68.17586, 116.5777 +21717, 69.85767, 136.0274 +21718, 66.60797, 119.7939 +21719, 69.08158, 145.2811 +21720, 67.16475, 120.9003 +21721, 66.35066, 114.9647 +21722, 66.59299, 129.3826 +21723, 65.04067, 101.3936 +21724, 68.30625, 124.8439 +21725, 67.6115, 129.8552 +21726, 69.20628, 146.9622 +21727, 70.44549, 146.535 +21728, 70.91437, 136.5757 +21729, 65.42417, 133.412 +21730, 67.54349, 139.8108 +21731, 67.24006, 129.7754 +21732, 68.186, 139.256 +21733, 66.55056, 104.7859 +21734, 68.61863, 141.8655 +21735, 68.3969, 138.2968 +21736, 69.25466, 123.9714 +21737, 66.51789, 122.2101 +21738, 69.53102, 130.8152 +21739, 67.84335, 134.6077 +21740, 67.73899, 123.6453 +21741, 69.10056, 133.7242 +21742, 67.22282, 136.6474 +21743, 70.14077, 117.6351 +21744, 66.63163, 127.9701 +21745, 69.45646, 136.697 +21746, 69.02288, 157.9236 +21747, 69.04845, 144.0225 +21748, 65.98766, 115.1328 +21749, 68.32236, 137.4591 +21750, 69.06911, 130.3359 +21751, 67.6674, 128.978 +21752, 67.94975, 129.5573 +21753, 68.79124, 110.5886 +21754, 68.35343, 138.2477 +21755, 68.31792, 137.2072 +21756, 69.47505, 131.5983 +21757, 67.39877, 108.4221 +21758, 67.90904, 129.8693 +21759, 69.51989, 142.6941 +21760, 67.83781, 148.7128 +21761, 65.60406, 115.2958 +21762, 68.8712, 135.0711 +21763, 67.41876, 114.7234 +21764, 66.89864, 112.6633 +21765, 67.05157, 111.2213 +21766, 68.65952, 126.4751 +21767, 68.82781, 124.8432 +21768, 68.27979, 132.045 +21769, 67.24388, 126.8469 +21770, 65.70125, 118.0533 +21771, 68.53534, 142.5502 +21772, 68.97033, 135.912 +21773, 69.42265, 123.1637 +21774, 65.89796, 116.9465 +21775, 67.48926, 121.2539 +21776, 68.24839, 126.698 +21777, 69.9615, 142.6772 +21778, 69.1349, 133.9896 +21779, 65.7668, 114.8528 +21780, 69.31519, 132.0639 +21781, 67.68043, 112.7006 +21782, 65.7642, 105.172 +21783, 68.65969, 107.7614 +21784, 72.48764, 132.3992 +21785, 64.78256, 110.153 +21786, 70.4841, 159.2503 +21787, 69.67148, 143.2815 +21788, 65.12354, 134.8383 +21789, 68.17589, 135.8612 +21790, 68.75037, 129.4885 +21791, 67.50063, 144.4117 +21792, 66.18238, 115.3209 +21793, 66.93648, 142.2417 +21794, 67.71915, 134.6098 +21795, 66.15708, 124.7595 +21796, 68.60607, 121.8448 +21797, 64.407, 116.1544 +21798, 65.95004, 110.1839 +21799, 69.6538, 107.6804 +21800, 67.30606, 131.0374 +21801, 69.65916, 124.3081 +21802, 68.25471, 144.5448 +21803, 67.50858, 135.5885 +21804, 68.8211, 142.21 +21805, 67.96832, 132.0779 +21806, 66.09807, 113.2875 +21807, 68.6238, 134.5527 +21808, 66.2588, 131.9464 +21809, 65.78144, 121.6553 +21810, 63.68103, 113.8491 +21811, 68.96781, 117.3037 +21812, 69.61369, 120.1962 +21813, 67.9393, 131.376 +21814, 72.12761, 141.5293 +21815, 66.17765, 108.006 +21816, 64.44865, 113.84 +21817, 66.9381, 124.7886 +21818, 69.72663, 138.5469 +21819, 66.50238, 144.8476 +21820, 67.66821, 122.3427 +21821, 68.21966, 127.736 +21822, 66.23247, 107.7751 +21823, 68.48757, 111.7849 +21824, 66.72098, 123.6466 +21825, 67.26512, 110.1107 +21826, 67.97088, 127.9019 +21827, 71.33619, 141.8512 +21828, 67.42918, 123.1017 +21829, 69.16961, 120.2536 +21830, 69.73638, 127.9477 +21831, 66.88932, 118.3424 +21832, 67.92182, 102.3229 +21833, 68.65846, 123.3907 +21834, 68.9523, 124.4188 +21835, 63.26116, 131.8104 +21836, 68.1796, 139.1423 +21837, 69.04181, 137.5828 +21838, 66.5111, 116.7547 +21839, 69.76603, 127.3629 +21840, 68.24223, 124.3347 +21841, 68.84887, 136.3807 +21842, 67.04484, 127.0678 +21843, 70.93046, 126.9017 +21844, 68.51393, 136.1465 +21845, 71.06022, 111.4244 +21846, 65.47707, 106.8859 +21847, 68.63389, 114.5655 +21848, 68.18722, 118.3686 +21849, 67.06874, 123.2887 +21850, 67.62436, 129.2202 +21851, 68.97729, 130.823 +21852, 67.66502, 117.9736 +21853, 69.96163, 120.0183 +21854, 64.63866, 108.6377 +21855, 66.42798, 116.0001 +21856, 67.91525, 103.1791 +21857, 66.84693, 116.1444 +21858, 66.66734, 129.0009 +21859, 68.74944, 150.8735 +21860, 66.35019, 124.4368 +21861, 68.74957, 131.2495 +21862, 67.15931, 110.9528 +21863, 68.07741, 122.6487 +21864, 73.25176, 148.2284 +21865, 67.62804, 122.5984 +21866, 70.98337, 122.6745 +21867, 68.14991, 122.0117 +21868, 68.73907, 126.2233 +21869, 65.52461, 113.7172 +21870, 65.35162, 110.6449 +21871, 64.35555, 113.8107 +21872, 68.55885, 127.5331 +21873, 69.0529, 133.1832 +21874, 72.60485, 143.9177 +21875, 69.48058, 115.4622 +21876, 66.25333, 113.0559 +21877, 65.40529, 109.6595 +21878, 70.28061, 119.1562 +21879, 70.37019, 116.2454 +21880, 65.48775, 125.4251 +21881, 66.53455, 123.3583 +21882, 67.5823, 121.7252 +21883, 65.69418, 125.5996 +21884, 68.03737, 134.0532 +21885, 68.47451, 123.5137 +21886, 65.23306, 116.1786 +21887, 67.86301, 125.1315 +21888, 65.79717, 123.5802 +21889, 71.44975, 133.3758 +21890, 70.84018, 136.3143 +21891, 71.18982, 141.107 +21892, 66.03097, 126.5347 +21893, 71.37742, 125.9633 +21894, 70.57756, 137.1181 +21895, 68.2458, 128.0182 +21896, 68.22017, 141.7363 +21897, 65.06244, 106.6877 +21898, 66.90634, 108.0455 +21899, 63.03862, 115.8658 +21900, 67.06774, 152.2417 +21901, 65.30894, 106.7987 +21902, 65.06679, 107.6525 +21903, 67.39673, 124.6423 +21904, 69.06112, 122.2679 +21905, 69.12434, 132.9822 +21906, 68.47088, 130.1302 +21907, 70.21144, 143.2455 +21908, 70.97244, 143.2283 +21909, 67.11423, 122.2441 +21910, 70.05116, 132.2902 +21911, 68.72983, 131.9808 +21912, 65.39469, 129.8896 +21913, 71.11058, 132.006 +21914, 63.52038, 122.4025 +21915, 68.03493, 121.5552 +21916, 64.8839, 130.9255 +21917, 68.16535, 123.2502 +21918, 69.34209, 124.7472 +21919, 69.55427, 112.586 +21920, 69.37897, 123.8323 +21921, 67.90715, 124.8204 +21922, 69.78616, 119.2747 +21923, 70.06486, 123.9407 +21924, 67.26241, 133.3415 +21925, 63.73139, 121.2644 +21926, 68.32099, 129.2511 +21927, 66.39081, 142.8419 +21928, 70.03989, 137.0893 +21929, 66.24433, 135.7157 +21930, 68.25743, 117.7142 +21931, 70.79829, 130.2646 +21932, 67.11709, 116.0134 +21933, 65.93811, 124.2235 +21934, 67.55474, 97.14789 +21935, 64.78244, 124.6147 +21936, 68.45511, 118.3446 +21937, 68.60516, 130.4597 +21938, 68.18953, 135.0554 +21939, 64.24981, 113.7089 +21940, 67.42016, 121.1719 +21941, 69.64799, 129.1334 +21942, 68.76641, 137.5208 +21943, 67.47039, 116.7224 +21944, 66.34719, 102.2607 +21945, 65.27345, 94.26051 +21946, 68.49649, 130.6183 +21947, 66.77663, 128.4905 +21948, 68.62434, 136.1352 +21949, 66.97798, 134.398 +21950, 74.42744, 141.7416 +21951, 68.16821, 110.4841 +21952, 69.58597, 134.9162 +21953, 64.67803, 128.0545 +21954, 69.98681, 130.8804 +21955, 68.74272, 136.6016 +21956, 67.56099, 137.7014 +21957, 63.59232, 107.4139 +21958, 69.05534, 151.567 +21959, 66.83137, 135.1775 +21960, 69.25699, 132.5855 +21961, 70.10878, 128.1379 +21962, 65.74458, 118.6861 +21963, 68.92381, 132.023 +21964, 63.45696, 101.8629 +21965, 66.46407, 114.2272 +21966, 65.32677, 112.1856 +21967, 70.28537, 127.3897 +21968, 73.62336, 145.5589 +21969, 72.06438, 133.0115 +21970, 63.99289, 118.1347 +21971, 69.13512, 125.715 +21972, 69.11398, 115.0134 +21973, 68.8397, 119.2542 +21974, 68.42829, 125.7109 +21975, 69.11164, 126.3794 +21976, 67.75382, 133.1108 +21977, 68.28205, 130.0354 +21978, 69.79824, 140.2748 +21979, 67.80131, 125.3779 +21980, 66.92047, 117.4567 +21981, 65.41043, 110.3167 +21982, 67.2104, 118.1644 +21983, 69.23036, 104.0257 +21984, 69.02497, 127.7908 +21985, 65.27684, 145.1158 +21986, 69.48104, 139.7665 +21987, 70.35139, 148.13 +21988, 66.72914, 110.6124 +21989, 69.18346, 124.9384 +21990, 69.39009, 117.0886 +21991, 65.10415, 122.9297 +21992, 70.42201, 132.063 +21993, 64.20998, 124.7386 +21994, 66.39326, 110.6721 +21995, 67.99051, 130.6448 +21996, 66.54414, 127.2514 +21997, 67.85205, 120.743 +21998, 68.3302, 147.7192 +21999, 67.70322, 116.5958 +22000, 67.08778, 126.0409 +22001, 67.45991, 131.0766 +22002, 64.53855, 103.166 +22003, 68.77395, 120.2698 +22004, 65.27979, 120.4821 +22005, 69.89596, 114.4375 +22006, 66.11113, 121.7524 +22007, 69.19728, 138.7705 +22008, 68.62235, 127.2493 +22009, 70.33159, 152.9261 +22010, 69.44904, 126.7259 +22011, 70.18822, 153.6557 +22012, 68.18276, 135.8523 +22013, 64.73962, 108.7094 +22014, 69.52012, 132.428 +22015, 68.40112, 115.1738 +22016, 68.4364, 121.9109 +22017, 69.7165, 113.6107 +22018, 65.8825, 117.5802 +22019, 67.92953, 105.9806 +22020, 67.02377, 130.0163 +22021, 68.48076, 122.6201 +22022, 70.66957, 126.6477 +22023, 67.61492, 134.6768 +22024, 73.58866, 153.0783 +22025, 66.98903, 119.4068 +22026, 70.73654, 151.4389 +22027, 70.82435, 140.2097 +22028, 67.78555, 110.19 +22029, 67.01787, 127.3742 +22030, 67.07288, 137.5581 +22031, 69.53889, 129.2925 +22032, 64.16684, 128.8207 +22033, 66.59597, 117.7506 +22034, 66.02727, 121.3984 +22035, 69.90695, 127.6222 +22036, 66.31378, 128.1986 +22037, 71.0924, 157.3921 +22038, 69.1847, 130.0327 +22039, 69.53601, 139.6967 +22040, 69.43737, 126.2871 +22041, 66.46531, 118.2134 +22042, 69.60722, 130.2072 +22043, 68.40154, 126.3804 +22044, 66.58472, 124.3242 +22045, 67.65364, 132.7654 +22046, 65.62466, 132.5228 +22047, 67.55476, 138.0942 +22048, 67.67129, 129.3039 +22049, 71.35689, 135.5968 +22050, 67.23927, 145.4296 +22051, 66.4871, 119.4681 +22052, 69.16735, 124.7664 +22053, 69.7819, 117.0658 +22054, 66.7397, 123.7996 +22055, 70.68935, 140.8345 +22056, 67.5828, 124.7307 +22057, 66.10625, 128.8248 +22058, 70.29985, 153.2173 +22059, 69.77906, 141.0626 +22060, 67.07765, 126.0482 +22061, 65.67584, 121.7947 +22062, 65.93844, 126.4153 +22063, 71.89509, 127.5677 +22064, 67.92099, 109.7213 +22065, 70.56492, 143.6368 +22066, 64.88248, 107.027 +22067, 71.8284, 131.3314 +22068, 68.76645, 127.0974 +22069, 66.38695, 107.555 +22070, 66.21688, 118.3435 +22071, 70.84942, 138.4765 +22072, 68.79234, 125.5644 +22073, 69.99779, 131.4314 +22074, 64.83696, 142.2888 +22075, 66.68908, 130.1091 +22076, 64.81045, 115.7425 +22077, 71.13578, 141.1345 +22078, 68.08155, 124.9248 +22079, 66.47646, 121.6753 +22080, 70.8782, 153.3804 +22081, 67.83647, 116.1852 +22082, 68.67074, 136.5908 +22083, 69.34659, 131.303 +22084, 67.01988, 112.523 +22085, 63.74803, 103.3567 +22086, 68.12093, 113.5474 +22087, 71.9073, 153.8792 +22088, 68.39398, 130.7981 +22089, 69.89219, 143.0116 +22090, 67.92004, 132.341 +22091, 69.5779, 145.1589 +22092, 67.4598, 122.5588 +22093, 67.62244, 123.0214 +22094, 67.1134, 126.3654 +22095, 68.88195, 116.6333 +22096, 66.77155, 136.6336 +22097, 66.44019, 130.1774 +22098, 68.75179, 130.6616 +22099, 70.97369, 129.0189 +22100, 67.69709, 124.2238 +22101, 67.55783, 117.3321 +22102, 69.39296, 132.2173 +22103, 66.57, 126.0029 +22104, 68.4234, 114.5145 +22105, 66.2871, 131.8304 +22106, 67.95212, 128.0529 +22107, 67.00587, 124.613 +22108, 66.13305, 123.0369 +22109, 67.94284, 130.1582 +22110, 66.8761, 135.8472 +22111, 67.88451, 131.2437 +22112, 64.79759, 116.9411 +22113, 67.83546, 134.9498 +22114, 68.28544, 117.8027 +22115, 66.99732, 136.9152 +22116, 66.70636, 133.6125 +22117, 67.99473, 111.8341 +22118, 68.56614, 133.2531 +22119, 63.70894, 125.1008 +22120, 67.39951, 134.5424 +22121, 67.68099, 140.1474 +22122, 64.98122, 108.9518 +22123, 69.4232, 123.6302 +22124, 70.00146, 149.3087 +22125, 71.36114, 144.8643 +22126, 66.60996, 121.845 +22127, 67.09436, 115.8078 +22128, 70.12298, 145.3622 +22129, 66.03876, 135.1259 +22130, 66.27712, 129.0541 +22131, 67.62592, 131.2538 +22132, 65.95321, 109.7856 +22133, 68.48038, 130.1038 +22134, 65.65352, 118.0966 +22135, 72.12181, 147.585 +22136, 67.40851, 146.4429 +22137, 69.88715, 134.4733 +22138, 69.27105, 154.4557 +22139, 71.93958, 152.5295 +22140, 66.98862, 115.2594 +22141, 69.88329, 127.6165 +22142, 69.06831, 142.8685 +22143, 68.37576, 146.4785 +22144, 72.36275, 141.3837 +22145, 65.32142, 96.822 +22146, 67.06859, 133.4834 +22147, 68.08786, 124.3863 +22148, 71.55388, 136.8521 +22149, 69.55143, 119.9292 +22150, 68.24976, 132.8025 +22151, 69.17304, 120.0536 +22152, 70.54788, 136.8571 +22153, 67.5523, 115.2183 +22154, 66.68536, 135.8133 +22155, 66.47161, 121.4223 +22156, 68.24878, 143.2844 +22157, 70.94761, 133.8643 +22158, 67.82211, 121.5944 +22159, 66.99944, 123.4547 +22160, 69.05494, 128.4013 +22161, 67.15164, 119.0471 +22162, 69.05272, 147.0719 +22163, 67.94938, 113.3519 +22164, 70.70493, 150.7817 +22165, 65.96851, 115.2572 +22166, 65.66304, 104.3101 +22167, 67.91282, 121.6957 +22168, 68.97438, 122.827 +22169, 69.66398, 133.2072 +22170, 66.46308, 147.6569 +22171, 64.40454, 119.04 +22172, 67.10339, 127.6042 +22173, 68.39658, 110.7311 +22174, 65.04915, 123.1842 +22175, 65.33805, 133.3083 +22176, 69.8495, 128.4304 +22177, 70.79219, 116.7218 +22178, 69.86252, 142.5929 +22179, 64.08728, 114.6547 +22180, 67.75657, 127.4783 +22181, 66.57296, 125.5804 +22182, 65.95543, 119.1968 +22183, 67.27865, 124.621 +22184, 63.76783, 119.2237 +22185, 65.67411, 133.6584 +22186, 68.27234, 139.0601 +22187, 66.29509, 122.8579 +22188, 66.30592, 118.0936 +22189, 65.17403, 125.2493 +22190, 65.36657, 118.4034 +22191, 70.09668, 134.7715 +22192, 67.49154, 135.2386 +22193, 71.89162, 135.7549 +22194, 70.80254, 139.8002 +22195, 68.10091, 95.27771 +22196, 65.66029, 132.4741 +22197, 65.09694, 123.0223 +22198, 66.33209, 110.2627 +22199, 68.60514, 139.9802 +22200, 66.0317, 101.1566 +22201, 69.62638, 141.8247 +22202, 67.93519, 138.7177 +22203, 66.51344, 117.3527 +22204, 68.79437, 129.367 +22205, 69.85071, 133.4628 +22206, 68.56043, 126.5705 +22207, 65.15652, 110.9314 +22208, 67.67203, 121.017 +22209, 71.47108, 133.0386 +22210, 67.893, 125.5458 +22211, 65.36284, 122.8713 +22212, 68.20304, 126.67 +22213, 64.78973, 113.3012 +22214, 66.79185, 133.5896 +22215, 68.86132, 124.0532 +22216, 66.84413, 132.7674 +22217, 67.68374, 122.9456 +22218, 69.02992, 116.8819 +22219, 68.4131, 145.2036 +22220, 68.72312, 127.6754 +22221, 69.07539, 119.1678 +22222, 64.79406, 119.185 +22223, 68.20087, 125.924 +22224, 70.01234, 131.9024 +22225, 68.42995, 132.477 +22226, 66.58476, 110.4114 +22227, 68.27708, 109.3802 +22228, 68.22959, 153.4104 +22229, 64.99611, 124.0648 +22230, 69.04964, 137.6179 +22231, 66.26221, 124.3251 +22232, 69.57317, 148.4155 +22233, 71.58799, 128.2996 +22234, 64.67557, 122.1539 +22235, 64.75449, 126.3476 +22236, 68.73197, 133.4295 +22237, 67.67754, 141.1335 +22238, 67.92076, 125.3999 +22239, 66.36387, 115.1711 +22240, 64.70157, 123.7421 +22241, 66.85773, 131.6002 +22242, 67.53255, 129.7075 +22243, 66.06081, 125.8923 +22244, 68.08335, 131.1495 +22245, 70.50547, 131.9548 +22246, 65.92983, 122.5229 +22247, 69.70668, 125.4368 +22248, 70.89685, 150.7064 +22249, 67.66278, 115.7167 +22250, 70.95408, 136.2602 +22251, 71.28145, 140.2041 +22252, 68.15606, 147.0766 +22253, 67.59876, 113.8641 +22254, 67.48336, 136.762 +22255, 68.24318, 118.4243 +22256, 66.80036, 135.7861 +22257, 67.16489, 121.1942 +22258, 69.37906, 129.4147 +22259, 68.19199, 127.1902 +22260, 67.68815, 133.5415 +22261, 70.95609, 134.0273 +22262, 70.27042, 133.8297 +22263, 66.56488, 135.5664 +22264, 70.52776, 140.0465 +22265, 69.02233, 131.4256 +22266, 72.34913, 140.7812 +22267, 67.03635, 124.2948 +22268, 69.90606, 143.0028 +22269, 71.44901, 130.5197 +22270, 68.37323, 121.8766 +22271, 66.7327, 107.9074 +22272, 64.94584, 104.0162 +22273, 66.81655, 107.7306 +22274, 69.28764, 122.0171 +22275, 69.39732, 116.0082 +22276, 65.91704, 116.9297 +22277, 64.86837, 115.2735 +22278, 63.55164, 119.2598 +22279, 70.44002, 149.2576 +22280, 68.09522, 117.641 +22281, 68.10961, 126.8252 +22282, 67.27297, 146.7294 +22283, 64.1425, 91.37972 +22284, 64.02389, 92.55327 +22285, 66.53104, 139.6883 +22286, 66.97558, 125.6853 +22287, 70.25009, 142.8251 +22288, 68.34103, 121.3014 +22289, 67.49306, 124.8288 +22290, 68.9249, 136.115 +22291, 68.2984, 139.7633 +22292, 67.57662, 122.0482 +22293, 68.30339, 113.878 +22294, 64.49314, 136.2782 +22295, 70.97046, 138.3778 +22296, 66.36863, 134.281 +22297, 63.76287, 112.4485 +22298, 67.57329, 119.1817 +22299, 67.92684, 141.4374 +22300, 66.16697, 113.6853 +22301, 66.34329, 135.2088 +22302, 69.95923, 139.5936 +22303, 68.90018, 124.9902 +22304, 68.56348, 136.245 +22305, 68.30793, 141.0644 +22306, 69.43004, 133.9346 +22307, 67.64037, 122.9113 +22308, 71.4182, 132.1873 +22309, 69.04964, 142.7013 +22310, 67.39319, 121.8913 +22311, 69.45379, 129.8532 +22312, 63.44375, 109.1048 +22313, 68.43154, 135.2451 +22314, 65.74265, 118.765 +22315, 69.89797, 139.0575 +22316, 69.04994, 126.7366 +22317, 70.71294, 118.9324 +22318, 66.53418, 113.3842 +22319, 66.23135, 111.8218 +22320, 68.21149, 121.5553 +22321, 65.49434, 117.2374 +22322, 66.9114, 137.1524 +22323, 64.09729, 112.0671 +22324, 68.66012, 129.1182 +22325, 70.23702, 130.4602 +22326, 64.64689, 116.0481 +22327, 66.20455, 119.7629 +22328, 68.73289, 118.1634 +22329, 67.14691, 143.8829 +22330, 65.14466, 128.5075 +22331, 64.89881, 118.0226 +22332, 68.72325, 126.7209 +22333, 68.02931, 127.2642 +22334, 65.49921, 138.8997 +22335, 70.07897, 124.0463 +22336, 65.80961, 122.0785 +22337, 68.17208, 126.3151 +22338, 68.34963, 116.8118 +22339, 70.21958, 133.1982 +22340, 68.84447, 135.5874 +22341, 67.94979, 121.2596 +22342, 65.27381, 105.3339 +22343, 66.23461, 126.2458 +22344, 67.1436, 111.9571 +22345, 65.90468, 126.1104 +22346, 69.99086, 147.0435 +22347, 65.17115, 122.095 +22348, 69.63168, 149.5493 +22349, 66.90136, 127.7358 +22350, 64.91721, 127.0199 +22351, 71.97009, 144.7114 +22352, 65.46509, 114.3207 +22353, 69.56498, 142.8489 +22354, 68.3429, 136.2659 +22355, 63.43363, 130.6775 +22356, 65.46842, 122.375 +22357, 67.08889, 111.5552 +22358, 69.81623, 133.9541 +22359, 67.95191, 124.754 +22360, 69.45766, 123.6822 +22361, 66.40296, 126.6477 +22362, 68.39926, 122.2508 +22363, 68.96552, 122.0338 +22364, 70.89678, 159.438 +22365, 67.65672, 145.5204 +22366, 67.53701, 120.4889 +22367, 66.81162, 118.2279 +22368, 69.88334, 133.8676 +22369, 68.6168, 134.1446 +22370, 67.45962, 122.1682 +22371, 70.80403, 144.2832 +22372, 67.18316, 135.5907 +22373, 68.50765, 134.9876 +22374, 68.76787, 128.1724 +22375, 68.43434, 126.9071 +22376, 66.47823, 111.5383 +22377, 67.34436, 121.6583 +22378, 65.02414, 129.485 +22379, 67.19022, 111.6239 +22380, 68.52752, 114.7147 +22381, 68.88508, 139.316 +22382, 66.13478, 114.642 +22383, 67.98273, 132.5035 +22384, 69.229, 123.9145 +22385, 69.38501, 119.8229 +22386, 68.09481, 122.3788 +22387, 68.35242, 138.5489 +22388, 68.641, 125.5334 +22389, 70.81774, 123.9536 +22390, 67.41551, 146.1271 +22391, 70.62572, 144.159 +22392, 66.74351, 118.2665 +22393, 70.06192, 124.4469 +22394, 67.44022, 140.4945 +22395, 67.20582, 112.23 +22396, 68.96137, 121.5742 +22397, 67.16343, 118.3616 +22398, 69.11617, 127.4023 +22399, 67.19284, 119.2573 +22400, 70.04124, 127.3701 +22401, 65.39474, 118.9921 +22402, 69.78766, 136.6437 +22403, 65.78283, 106.2273 +22404, 70.85273, 136.7051 +22405, 67.26176, 114.9494 +22406, 65.82405, 117.3282 +22407, 67.87583, 118.4041 +22408, 68.89097, 131.2082 +22409, 68.26679, 146.8878 +22410, 69.18241, 106.3253 +22411, 70.00856, 126.6624 +22412, 67.79094, 130.9155 +22413, 71.07725, 142.6734 +22414, 68.53121, 125.742 +22415, 70.69622, 130.7612 +22416, 68.34285, 122.5753 +22417, 67.88412, 131.1011 +22418, 69.09173, 119.5692 +22419, 64.19111, 131.5028 +22420, 65.58191, 114.5981 +22421, 67.00245, 135.268 +22422, 72.50619, 141.3209 +22423, 67.29625, 123.9061 +22424, 64.37806, 122.5322 +22425, 66.53719, 106.8997 +22426, 66.73451, 120.6642 +22427, 67.1243, 126.1548 +22428, 68.93399, 141.4405 +22429, 68.1547, 121.1812 +22430, 64.69305, 105.483 +22431, 70.17224, 135.2665 +22432, 65.44791, 119.2957 +22433, 66.75949, 133.259 +22434, 72.58158, 159.1321 +22435, 66.85111, 120.6395 +22436, 67.85314, 132.4666 +22437, 66.56029, 115.992 +22438, 66.60117, 105.015 +22439, 68.16608, 137.8016 +22440, 68.02612, 131.4764 +22441, 70.43453, 134.9766 +22442, 70.448, 122.5178 +22443, 66.79366, 121.7954 +22444, 67.93008, 104.9369 +22445, 67.53134, 120.2005 +22446, 64.0635, 110.7893 +22447, 67.46311, 122.3789 +22448, 65.64829, 106.5113 +22449, 65.50176, 127.0283 +22450, 65.19088, 137.0147 +22451, 73.55973, 143.8236 +22452, 67.48872, 128.3561 +22453, 71.66711, 136.453 +22454, 66.5003, 134.2579 +22455, 70.47009, 134.5955 +22456, 68.77001, 104.3631 +22457, 66.6715, 133.7417 +22458, 66.8153, 119.2792 +22459, 67.02357, 146.3363 +22460, 67.20076, 133.7343 +22461, 70.29408, 122.478 +22462, 67.91383, 130.3713 +22463, 65.94586, 106.4359 +22464, 67.94159, 127.6529 +22465, 68.59362, 121.6743 +22466, 67.31884, 102.4131 +22467, 69.48282, 132.2356 +22468, 67.43331, 102.8806 +22469, 68.54895, 127.8072 +22470, 67.08363, 123.5613 +22471, 68.71345, 123.6214 +22472, 74.51784, 146.9867 +22473, 71.11623, 126.5249 +22474, 66.6034, 132.068 +22475, 65.16296, 131.9835 +22476, 67.40019, 119.562 +22477, 70.16146, 129.2907 +22478, 65.61241, 125.0266 +22479, 69.34532, 142.6343 +22480, 70.28985, 120.4244 +22481, 63.28424, 102.8488 +22482, 67.56905, 138.245 +22483, 64.16839, 117.9972 +22484, 68.38401, 113.6476 +22485, 63.44102, 105.99 +22486, 70.16228, 152.0325 +22487, 67.14157, 119.621 +22488, 67.3811, 134.1843 +22489, 71.23103, 135.0203 +22490, 71.63547, 135.9923 +22491, 69.82003, 141.106 +22492, 63.77542, 117.014 +22493, 68.54253, 133.6109 +22494, 64.10125, 112.2048 +22495, 67.39109, 142.0633 +22496, 69.56071, 117.9541 +22497, 67.46663, 132.0557 +22498, 66.90103, 114.3497 +22499, 66.12243, 122.077 +22500, 65.6892, 118.8169 +22501, 65.1204, 118.9654 +22502, 67.16597, 126.5318 +22503, 67.33179, 132.7412 +22504, 65.43456, 132.9256 +22505, 71.01314, 144.9404 +22506, 67.13382, 139.0221 +22507, 70.73742, 139.8123 +22508, 61.5772, 96.8142 +22509, 65.29383, 126.8247 +22510, 68.56296, 129.1019 +22511, 67.5144, 122.6961 +22512, 72.21583, 141.0306 +22513, 70.28404, 128.3399 +22514, 71.11178, 143.1083 +22515, 65.76568, 130.449 +22516, 68.03973, 128.1704 +22517, 68.16794, 130.1159 +22518, 66.20705, 121.4541 +22519, 67.45865, 135.8331 +22520, 68.06964, 107.1248 +22521, 68.40912, 142.847 +22522, 68.36422, 129.5642 +22523, 68.2454, 147.5186 +22524, 68.48681, 138.3336 +22525, 67.05044, 128.3177 +22526, 70.19008, 130.5503 +22527, 69.81118, 129.5179 +22528, 70.02186, 147.9327 +22529, 65.66764, 126.892 +22530, 68.29689, 128.3698 +22531, 68.96595, 113.4953 +22532, 64.81674, 125.2063 +22533, 67.12839, 125.9876 +22534, 68.09125, 106.3661 +22535, 68.70922, 133.285 +22536, 68.68883, 102.1817 +22537, 66.17566, 105.552 +22538, 66.59899, 112.7548 +22539, 66.343, 108.918 +22540, 69.56934, 147.6161 +22541, 70.46931, 121.3031 +22542, 69.28264, 134.4014 +22543, 65.39677, 118.5694 +22544, 65.71084, 117.2162 +22545, 68.83017, 137.2144 +22546, 66.59626, 119.4922 +22547, 64.3308, 120.3128 +22548, 68.47765, 137.3295 +22549, 65.57002, 122.3498 +22550, 70.5056, 139.8634 +22551, 64.50765, 117.6468 +22552, 65.13344, 115.206 +22553, 64.89306, 118.7128 +22554, 68.39202, 120.7594 +22555, 67.7322, 135.0784 +22556, 68.13899, 132.4274 +22557, 65.15771, 127.3552 +22558, 67.62358, 116.1185 +22559, 66.69655, 129.1073 +22560, 68.34154, 120.2991 +22561, 70.32266, 137.2463 +22562, 72.36994, 161.072 +22563, 71.00524, 135.5327 +22564, 67.51452, 117.0815 +22565, 68.86769, 134.6847 +22566, 71.92456, 140.8061 +22567, 69.60134, 137.1303 +22568, 71.14383, 145.1859 +22569, 69.61626, 119.6241 +22570, 68.93692, 131.6676 +22571, 69.42922, 132.3479 +22572, 67.17672, 140.0865 +22573, 69.72196, 128.3285 +22574, 70.60744, 132.7756 +22575, 67.34019, 127.3799 +22576, 66.31079, 126.9478 +22577, 67.23639, 129.5258 +22578, 66.2918, 121.0966 +22579, 69.50398, 136.2028 +22580, 66.49436, 113.3199 +22581, 70.58993, 133.791 +22582, 68.92044, 139.3391 +22583, 71.77031, 132.9198 +22584, 68.50443, 119.7086 +22585, 69.39218, 115.8239 +22586, 68.6537, 126.212 +22587, 66.18463, 133.7102 +22588, 68.33578, 125.5068 +22589, 66.10103, 120.5161 +22590, 67.31834, 134.4938 +22591, 68.14329, 140.9484 +22592, 67.54457, 113.9351 +22593, 68.89329, 132.902 +22594, 67.78014, 114.3622 +22595, 72.29726, 130.9845 +22596, 69.89756, 138.4082 +22597, 68.68682, 129.1788 +22598, 68.22197, 129.9893 +22599, 68.06326, 122.2425 +22600, 70.50201, 121.5432 +22601, 66.80934, 127.5672 +22602, 65.84644, 114.6007 +22603, 65.26085, 108.4305 +22604, 67.03193, 124.5872 +22605, 69.69241, 134.7945 +22606, 67.68945, 126.7584 +22607, 64.90842, 115.6715 +22608, 69.7312, 145.1096 +22609, 70.9839, 149.7127 +22610, 65.35669, 113.8631 +22611, 70.94864, 141.6714 +22612, 66.61118, 127.3027 +22613, 67.8403, 126.3388 +22614, 70.30731, 113.6596 +22615, 67.19256, 118.4278 +22616, 72.6701, 153.4343 +22617, 69.11157, 146.5177 +22618, 65.42909, 96.09124 +22619, 66.69501, 115.1204 +22620, 67.2699, 119.5571 +22621, 66.82154, 106.1513 +22622, 66.56659, 120.8269 +22623, 68.05305, 121.1583 +22624, 69.85664, 127.7646 +22625, 69.45607, 112.218 +22626, 65.00963, 133.8473 +22627, 70.59848, 142.1744 +22628, 70.32798, 145.7059 +22629, 71.92476, 137.7201 +22630, 72.18595, 134.2977 +22631, 68.29702, 125.3716 +22632, 72.45555, 135.889 +22633, 67.70906, 116.7369 +22634, 65.63799, 127.0389 +22635, 68.38226, 140.6609 +22636, 65.644, 134.9545 +22637, 69.68159, 129.241 +22638, 69.47913, 151.5039 +22639, 72.95987, 156.0008 +22640, 69.56484, 129.0326 +22641, 70.69665, 130.411 +22642, 66.5653, 130.9523 +22643, 66.0725, 113.1841 +22644, 68.68202, 131.7641 +22645, 64.4832, 117.5189 +22646, 66.84969, 112.0469 +22647, 66.68227, 105.1667 +22648, 68.65461, 122.6123 +22649, 69.72195, 118.0798 +22650, 69.39789, 117.1566 +22651, 70.61082, 125.1074 +22652, 66.22358, 110.4053 +22653, 70.31099, 126.7549 +22654, 68.85282, 134.3575 +22655, 69.84827, 129.8123 +22656, 69.80382, 120.1583 +22657, 66.79719, 113.3404 +22658, 68.78234, 136.1364 +22659, 68.63042, 142.019 +22660, 67.06382, 138.7234 +22661, 66.47369, 111.6471 +22662, 67.0678, 121.6606 +22663, 70.53877, 153.2208 +22664, 69.15369, 123.9976 +22665, 66.29498, 125.3838 +22666, 66.87256, 133.81 +22667, 67.12544, 134.5897 +22668, 69.56909, 131.9905 +22669, 67.03174, 136.702 +22670, 66.4968, 127.9662 +22671, 67.5556, 109.1244 +22672, 67.93723, 149.1814 +22673, 66.27955, 131.2398 +22674, 70.08345, 127.6921 +22675, 67.35558, 112.0268 +22676, 64.76129, 135.324 +22677, 69.37296, 119.6408 +22678, 68.95501, 122.0693 +22679, 67.90465, 120.3374 +22680, 66.71124, 117.9071 +22681, 65.76897, 119.6472 +22682, 69.74997, 139.8994 +22683, 68.41754, 144.6354 +22684, 70.48365, 141.2387 +22685, 68.69947, 126.1275 +22686, 67.91544, 139.3144 +22687, 64.26003, 138.8967 +22688, 69.46549, 139.5814 +22689, 72.00386, 126.9035 +22690, 68.50887, 137.5104 +22691, 68.6786, 148.859 +22692, 69.89895, 128.7758 +22693, 68.57138, 138.3081 +22694, 68.97025, 144.2462 +22695, 68.34718, 115.801 +22696, 72.38993, 135.652 +22697, 70.20578, 142.9711 +22698, 69.75085, 129.6653 +22699, 64.09194, 119.3224 +22700, 71.43266, 131.4454 +22701, 67.37224, 135.8829 +22702, 66.33348, 126.2756 +22703, 65.95623, 109.4862 +22704, 69.41866, 129.0734 +22705, 66.28843, 108.9547 +22706, 71.46665, 149.7074 +22707, 71.51152, 132.7706 +22708, 69.24771, 121.9716 +22709, 69.53177, 144.4003 +22710, 67.22302, 103.2602 +22711, 67.93135, 129.3014 +22712, 66.47411, 124.7407 +22713, 68.31675, 139.713 +22714, 73.35404, 150.7569 +22715, 67.46996, 125.8104 +22716, 68.76208, 145.3668 +22717, 66.09377, 139.3107 +22718, 67.45004, 123.2179 +22719, 67.8148, 123.4598 +22720, 67.34877, 126.6511 +22721, 71.09293, 136.7007 +22722, 66.02176, 142.9777 +22723, 66.60069, 127.9869 +22724, 69.93282, 138.0167 +22725, 68.7928, 138.5455 +22726, 65.98657, 111.6272 +22727, 66.96658, 125.4782 +22728, 68.02571, 120.8518 +22729, 67.76658, 132.3844 +22730, 71.68362, 121.7687 +22731, 68.13284, 137.313 +22732, 66.94959, 124.8775 +22733, 68.59926, 130.122 +22734, 68.17404, 138.4723 +22735, 65.94969, 128.6623 +22736, 67.78038, 145.0523 +22737, 69.16229, 133.4977 +22738, 68.84495, 135.0473 +22739, 62.87593, 87.80417 +22740, 65.38831, 114.5963 +22741, 69.61852, 138.186 +22742, 68.48205, 117.8466 +22743, 64.11049, 120.9648 +22744, 69.87984, 144.6479 +22745, 67.76735, 124.5242 +22746, 67.35451, 131.093 +22747, 70.00347, 141.6283 +22748, 67.782, 128.6523 +22749, 70.91393, 133.8196 +22750, 65.724, 116.8975 +22751, 69.41139, 111.6991 +22752, 67.93682, 132.6835 +22753, 68.58455, 127.992 +22754, 69.50539, 133.2801 +22755, 68.94904, 128.2592 +22756, 66.66785, 137.9687 +22757, 66.40117, 126.7388 +22758, 64.44764, 114.5613 +22759, 70.69015, 129.7884 +22760, 68.25112, 128.0135 +22761, 67.4473, 139.9757 +22762, 65.36833, 136.6826 +22763, 67.34133, 133.5039 +22764, 66.46421, 123.7168 +22765, 69.82447, 127.4811 +22766, 64.73067, 112.8504 +22767, 68.26578, 123.2698 +22768, 68.95561, 109.0392 +22769, 64.58086, 119.146 +22770, 74.19842, 141.6148 +22771, 66.6644, 121.794 +22772, 68.02958, 132.4556 +22773, 69.7998, 152.4869 +22774, 68.71084, 119.4949 +22775, 68.62699, 133.9088 +22776, 66.32223, 134.6167 +22777, 68.55855, 132.8311 +22778, 68.53141, 135.5661 +22779, 62.48689, 111.8165 +22780, 68.00704, 110.0622 +22781, 66.30784, 137.3814 +22782, 67.82081, 120.6221 +22783, 67.83951, 133.1991 +22784, 69.5902, 111.5373 +22785, 67.87211, 141.0278 +22786, 67.74583, 102.3371 +22787, 64.71388, 101.4857 +22788, 71.13759, 146.4352 +22789, 68.46782, 143.5551 +22790, 67.8517, 124.7309 +22791, 67.49456, 121.203 +22792, 68.90683, 126.8225 +22793, 66.26091, 108.851 +22794, 68.79987, 141.3204 +22795, 68.59418, 114.3444 +22796, 65.34823, 114.1506 +22797, 69.42848, 141.8919 +22798, 71.12497, 141.1445 +22799, 67.55908, 122.9483 +22800, 66.396, 119.9881 +22801, 68.62226, 119.503 +22802, 67.72435, 136.7854 +22803, 68.47464, 123.3189 +22804, 68.21036, 117.8225 +22805, 72.93173, 137.7735 +22806, 66.67029, 123.5324 +22807, 69.46618, 133.0678 +22808, 69.70422, 116.2886 +22809, 64.06811, 127.9847 +22810, 68.24092, 122.1935 +22811, 65.17573, 124.5714 +22812, 65.69849, 123.4044 +22813, 66.12188, 121.0018 +22814, 66.75351, 113.6246 +22815, 67.124, 130.327 +22816, 68.13272, 126.5551 +22817, 67.68052, 133.1014 +22818, 67.62642, 101.6002 +22819, 68.10599, 119.3721 +22820, 67.87029, 128.1651 +22821, 65.92455, 122.2294 +22822, 68.17315, 141.5252 +22823, 69.90983, 142.9065 +22824, 70.66076, 137.2266 +22825, 66.01225, 124.1513 +22826, 68.1509, 132.5444 +22827, 64.74223, 116.3991 +22828, 67.10415, 140.3787 +22829, 71.26494, 126.1828 +22830, 64.91946, 130.5654 +22831, 65.50098, 125.5682 +22832, 68.43887, 120.3856 +22833, 64.33844, 111.7705 +22834, 67.68823, 129.9065 +22835, 66.06957, 123.5877 +22836, 68.48965, 124.2906 +22837, 67.35924, 129.934 +22838, 67.16705, 118.2155 +22839, 66.10219, 125.8852 +22840, 69.4862, 124.0363 +22841, 70.51144, 140.7336 +22842, 68.89049, 125.4419 +22843, 67.11289, 115.4696 +22844, 69.51603, 139.5932 +22845, 68.86244, 131.8509 +22846, 67.76488, 133.5444 +22847, 65.95197, 126.4559 +22848, 65.55731, 110.9407 +22849, 72.43314, 128.1583 +22850, 68.05046, 126.5532 +22851, 63.42692, 114.5877 +22852, 70.12328, 133.688 +22853, 65.79126, 110.9996 +22854, 68.70108, 135.9715 +22855, 73.28207, 137.8167 +22856, 68.99273, 147.8318 +22857, 67.82843, 135.2744 +22858, 62.94505, 122.372 +22859, 69.51628, 126.2618 +22860, 67.94096, 116.288 +22861, 68.50625, 132.962 +22862, 67.95033, 114.1483 +22863, 68.24256, 128.3786 +22864, 66.74548, 120.3706 +22865, 68.97078, 134.1704 +22866, 67.89432, 119.747 +22867, 67.79059, 128.8443 +22868, 69.35969, 151.1659 +22869, 67.25605, 119.6419 +22870, 69.23614, 143.8642 +22871, 66.1292, 119.0279 +22872, 67.91232, 136.3911 +22873, 69.75562, 108.6263 +22874, 64.53749, 114.2815 +22875, 67.63726, 119.2335 +22876, 64.64337, 103.3826 +22877, 68.76465, 135.6549 +22878, 68.35968, 125.3602 +22879, 67.15012, 110.7928 +22880, 67.86118, 110.2807 +22881, 65.15809, 111.8642 +22882, 68.62459, 147.1759 +22883, 69.70212, 107.5978 +22884, 65.83099, 119.0626 +22885, 66.5626, 108.4966 +22886, 68.09845, 118.1344 +22887, 71.05128, 146.987 +22888, 67.73185, 113.9887 +22889, 70.68351, 137.5274 +22890, 66.52891, 121.9112 +22891, 69.66816, 132.621 +22892, 69.14886, 118.2569 +22893, 68.16218, 125.9458 +22894, 66.39514, 129.8475 +22895, 69.00165, 122.8649 +22896, 67.50031, 118.3179 +22897, 69.70684, 143.0038 +22898, 66.12548, 130.5276 +22899, 69.3575, 143.6705 +22900, 71.21111, 123.7803 +22901, 70.30626, 127.5549 +22902, 68.79866, 113.9144 +22903, 67.98332, 129.6498 +22904, 67.04034, 136.5138 +22905, 65.51177, 125.8274 +22906, 67.5647, 121.5267 +22907, 65.31898, 112.9453 +22908, 68.67641, 133.8246 +22909, 69.69018, 108.3043 +22910, 67.58645, 128.7129 +22911, 69.02146, 131.7672 +22912, 71.22346, 134.1668 +22913, 66.68869, 121.3149 +22914, 68.89188, 116.5565 +22915, 70.25429, 132.284 +22916, 66.69163, 113.6064 +22917, 71.23552, 149.4307 +22918, 72.23127, 136.0526 +22919, 69.14796, 127.1588 +22920, 68.3997, 137.7419 +22921, 69.1157, 137.5853 +22922, 67.44534, 123.8531 +22923, 67.22197, 120.25 +22924, 68.34089, 123.5174 +22925, 68.42363, 130.5575 +22926, 70.02078, 101.0972 +22927, 70.21496, 126.4946 +22928, 66.38077, 133.6296 +22929, 66.71388, 115.4801 +22930, 64.1655, 117.12 +22931, 71.24956, 137.0562 +22932, 69.89254, 147.3662 +22933, 68.98321, 135.968 +22934, 64.57034, 129.1319 +22935, 67.41889, 116.1147 +22936, 69.98766, 137.7019 +22937, 70.43488, 133.2956 +22938, 65.75904, 116.6186 +22939, 64.11045, 115.4852 +22940, 66.59156, 134.6647 +22941, 67.27675, 137.0794 +22942, 69.17155, 136.9795 +22943, 69.6518, 130.5147 +22944, 66.32536, 128.4373 +22945, 64.03352, 114.4831 +22946, 61.92639, 78.01476 +22947, 67.7671, 117.9652 +22948, 66.40118, 109.6265 +22949, 66.88433, 124.1093 +22950, 68.2887, 122.8747 +22951, 66.1441, 116.6754 +22952, 70.22583, 140.134 +22953, 68.68353, 137.0244 +22954, 71.08882, 137.2922 +22955, 64.53211, 112.4629 +22956, 66.54164, 115.2955 +22957, 67.46281, 130.815 +22958, 68.0421, 121.023 +22959, 65.46687, 124.5001 +22960, 68.52141, 113.6681 +22961, 67.96073, 126.2877 +22962, 66.57412, 121.4992 +22963, 67.40978, 137.7122 +22964, 67.55044, 146.7738 +22965, 64.99509, 110.056 +22966, 68.29555, 135.3666 +22967, 65.96557, 133.8862 +22968, 68.96821, 134.2673 +22969, 69.15112, 119.7562 +22970, 68.56283, 128.7529 +22971, 69.75078, 136.582 +22972, 67.47683, 102.3792 +22973, 70.38587, 126.0902 +22974, 68.33742, 135.0531 +22975, 68.81973, 142.3251 +22976, 68.62357, 110.3801 +22977, 63.33985, 102.0817 +22978, 69.12711, 117.5758 +22979, 67.89769, 121.003 +22980, 66.45348, 137.254 +22981, 65.60765, 117.6409 +22982, 69.61332, 124.3246 +22983, 65.2444, 100.6039 +22984, 70.00592, 138.7949 +22985, 68.27914, 126.7719 +22986, 68.01894, 140.9059 +22987, 66.99443, 125.0889 +22988, 66.27568, 120.1084 +22989, 67.53537, 142.9972 +22990, 66.97235, 112.1711 +22991, 70.63806, 145.3795 +22992, 62.8996, 122.5734 +22993, 69.89458, 138.0427 +22994, 71.93148, 145.0405 +22995, 68.87022, 125.7048 +22996, 68.93, 132.8748 +22997, 64.69495, 125.4599 +22998, 68.70088, 125.097 +22999, 69.00687, 141.8557 +23000, 67.0541, 127.0649 +23001, 66.03227, 105.2789 +23002, 65.47238, 123.0281 +23003, 68.47197, 116.8453 +23004, 72.86624, 155.6909 +23005, 69.44922, 122.5776 +23006, 67.63052, 125.2892 +23007, 68.2045, 100.3754 +23008, 66.53317, 124.1705 +23009, 67.27027, 129.1828 +23010, 65.41871, 117.4206 +23011, 71.23007, 141.3686 +23012, 65.94361, 116.2995 +23013, 68.6177, 135.2373 +23014, 70.50911, 124.1658 +23015, 69.85115, 120.489 +23016, 71.86882, 124.1575 +23017, 69.08754, 132.1762 +23018, 68.19593, 127.1534 +23019, 70.29545, 123.0092 +23020, 66.37047, 119.1916 +23021, 69.81223, 135.2679 +23022, 67.11791, 109.1436 +23023, 66.40278, 119.7731 +23024, 66.84852, 138.8225 +23025, 69.11523, 131.8907 +23026, 70.68754, 133.2559 +23027, 65.23047, 125.7246 +23028, 67.79963, 131.9513 +23029, 67.81254, 129.5695 +23030, 68.18637, 114.497 +23031, 64.72897, 113.9349 +23032, 67.22249, 131.9605 +23033, 67.93339, 115.2966 +23034, 66.48779, 120.5557 +23035, 66.56398, 120.0062 +23036, 66.75188, 105.1257 +23037, 66.02021, 126.5255 +23038, 67.9585, 127.2612 +23039, 67.75219, 110.8899 +23040, 73.95494, 154.3987 +23041, 68.63039, 141.3375 +23042, 62.37478, 129.29 +23043, 68.14198, 140.1522 +23044, 68.18139, 117.3218 +23045, 69.02633, 120.1428 +23046, 66.65396, 107.1014 +23047, 70.08721, 141.2284 +23048, 67.67278, 118.0272 +23049, 67.75081, 117.2739 +23050, 69.23325, 126.2547 +23051, 66.37194, 110.396 +23052, 70.10608, 147.4051 +23053, 69.31002, 138.6833 +23054, 68.90824, 136.5244 +23055, 68.92139, 134.8939 +23056, 67.23139, 132.9597 +23057, 65.72498, 138.466 +23058, 65.644, 115.7868 +23059, 67.33561, 143.0319 +23060, 69.78481, 131.0816 +23061, 70.59255, 139.4271 +23062, 68.63899, 122.564 +23063, 65.88659, 127.421 +23064, 68.58695, 138.1849 +23065, 72.62181, 131.941 +23066, 67.19948, 126.541 +23067, 63.83059, 95.14852 +23068, 66.5739, 121.3202 +23069, 68.18941, 124.102 +23070, 67.36899, 131.4176 +23071, 67.99917, 126.5831 +23072, 64.31329, 110.9314 +23073, 69.79204, 145.3659 +23074, 68.63117, 136.1348 +23075, 66.5155, 137.0524 +23076, 66.38747, 121.6402 +23077, 69.64946, 125.6207 +23078, 69.99201, 160.4327 +23079, 69.47095, 127.7372 +23080, 68.77016, 134.2468 +23081, 71.11019, 140.7725 +23082, 68.89861, 118.0075 +23083, 69.31258, 146.593 +23084, 69.5515, 139.4765 +23085, 64.91223, 119.4779 +23086, 68.37362, 118.1811 +23087, 69.53448, 128.3192 +23088, 71.24771, 154.2702 +23089, 68.83289, 127.9049 +23090, 70.97853, 139.8943 +23091, 68.7672, 143.2316 +23092, 70.09748, 131.3648 +23093, 66.41888, 138.25 +23094, 65.86975, 130.1757 +23095, 70.4954, 159.7426 +23096, 65.064, 105.9605 +23097, 66.23465, 146.7267 +23098, 63.36047, 101.3858 +23099, 65.49193, 111.6041 +23100, 69.78248, 123.3267 +23101, 67.16624, 108.0636 +23102, 69.51547, 125.7864 +23103, 68.25933, 117.6366 +23104, 69.56163, 123.3559 +23105, 68.51831, 132.3693 +23106, 68.80896, 133.7864 +23107, 68.56353, 140.9816 +23108, 67.83572, 124.3327 +23109, 69.41269, 142.6121 +23110, 69.68146, 129.8956 +23111, 67.64549, 143.3283 +23112, 66.05269, 122.8764 +23113, 66.27796, 107.2234 +23114, 65.97701, 122.1289 +23115, 66.49181, 104.5214 +23116, 69.4567, 127.3538 +23117, 65.33723, 121.5969 +23118, 66.57846, 124.3407 +23119, 68.01712, 137.5218 +23120, 71.9112, 138.2502 +23121, 69.96109, 142.6425 +23122, 66.49663, 115.0091 +23123, 69.70181, 127.0448 +23124, 68.75589, 117.8107 +23125, 68.24339, 124.7115 +23126, 71.0885, 134.7542 +23127, 69.22398, 128.7649 +23128, 65.73834, 132.8322 +23129, 66.723, 122.3498 +23130, 66.46585, 143.7961 +23131, 70.17314, 133.0561 +23132, 62.87311, 118.5005 +23133, 71.03165, 157.4647 +23134, 65.93252, 123.4121 +23135, 68.38672, 133.2561 +23136, 68.48179, 131.7267 +23137, 66.76412, 127.6081 +23138, 70.28787, 145.6777 +23139, 67.95232, 126.7402 +23140, 66.4042, 107.4818 +23141, 67.99874, 125.0152 +23142, 68.94294, 132.508 +23143, 66.99344, 117.7892 +23144, 67.73609, 127.2783 +23145, 65.91236, 138.3038 +23146, 69.29849, 141.5628 +23147, 69.19949, 127.7265 +23148, 67.43514, 143.9286 +23149, 71.4622, 132.334 +23150, 69.06087, 139.6586 +23151, 66.77321, 128.0555 +23152, 68.79889, 126.6591 +23153, 67.86558, 143.0202 +23154, 68.57647, 120.5964 +23155, 65.96871, 133.0051 +23156, 66.58142, 120.7591 +23157, 68.05952, 119.5858 +23158, 70.24508, 128.3668 +23159, 64.83437, 113.7229 +23160, 68.73522, 137.6596 +23161, 68.7765, 136.8831 +23162, 68.33747, 119.7698 +23163, 70.23944, 142.1361 +23164, 68.81975, 140.2789 +23165, 68.00236, 149.5672 +23166, 64.70248, 119.8107 +23167, 69.24303, 140.6072 +23168, 69.73554, 112.9331 +23169, 69.90308, 118.7222 +23170, 70.26048, 142.8739 +23171, 68.15806, 118.4471 +23172, 68.16444, 136.4492 +23173, 66.89046, 125.3586 +23174, 65.22883, 117.7991 +23175, 68.87187, 130.3033 +23176, 68.18349, 142.1478 +23177, 64.41925, 133.8882 +23178, 66.7988, 111.9541 +23179, 69.8922, 131.1349 +23180, 67.47421, 127.7576 +23181, 65.32392, 100.9973 +23182, 67.69222, 124.5089 +23183, 70.27339, 149.3882 +23184, 69.54348, 138.795 +23185, 73.32067, 131.1796 +23186, 66.05531, 120.903 +23187, 65.51404, 123.1225 +23188, 69.69787, 148.9949 +23189, 65.81341, 127.2974 +23190, 69.3073, 133.1362 +23191, 64.86268, 108.1662 +23192, 69.16539, 138.3731 +23193, 70.52093, 136.9358 +23194, 68.1878, 118.8524 +23195, 66.08498, 113.2371 +23196, 65.10427, 113.6349 +23197, 68.62122, 116.6541 +23198, 71.42976, 127.3845 +23199, 65.69791, 117.3124 +23200, 69.80748, 128.074 +23201, 69.92772, 136.1304 +23202, 69.41298, 130.348 +23203, 70.06942, 126.2846 +23204, 66.39166, 118.4999 +23205, 66.07042, 107.3307 +23206, 67.94108, 131.225 +23207, 66.88941, 127.8534 +23208, 68.96017, 124.9296 +23209, 69.5704, 156.8531 +23210, 68.2825, 128.9134 +23211, 66.7166, 130.1374 +23212, 66.72626, 108.1246 +23213, 66.57273, 114.7724 +23214, 68.04107, 126.3943 +23215, 68.6295, 139.1018 +23216, 68.49436, 113.7604 +23217, 66.39979, 114.3961 +23218, 68.28212, 132.8866 +23219, 68.52069, 139.9603 +23220, 69.03432, 120.0319 +23221, 64.99547, 129.0647 +23222, 67.91196, 112.3713 +23223, 66.91361, 116.2512 +23224, 70.70381, 139.5198 +23225, 67.40064, 137.1524 +23226, 69.05353, 127.2322 +23227, 65.85398, 121.7386 +23228, 66.79527, 121.806 +23229, 68.85892, 145.3855 +23230, 66.42832, 103.8422 +23231, 66.91067, 126.6949 +23232, 70.43889, 137.7195 +23233, 67.94999, 139.0592 +23234, 69.95065, 139.1737 +23235, 72.71908, 134.6013 +23236, 65.74199, 136.7099 +23237, 65.51557, 125.163 +23238, 70.21226, 119.1812 +23239, 69.16742, 128.4386 +23240, 68.82771, 105.6454 +23241, 68.60122, 132.7843 +23242, 65.56691, 127.4552 +23243, 69.79458, 120.7382 +23244, 68.50628, 131.7647 +23245, 66.57019, 116.6893 +23246, 70.03926, 134.5167 +23247, 67.9869, 141.6655 +23248, 71.22405, 151.3256 +23249, 68.74939, 126.1276 +23250, 67.24515, 139.1668 +23251, 67.73462, 114.4462 +23252, 67.46116, 127.3858 +23253, 69.2147, 140.1225 +23254, 67.51576, 126.9627 +23255, 66.10796, 114.8271 +23256, 68.5057, 117.2246 +23257, 66.73397, 122.3952 +23258, 69.36366, 125.575 +23259, 71.87173, 146.8516 +23260, 65.49077, 118.2955 +23261, 66.34021, 108.1274 +23262, 66.91425, 112.1228 +23263, 69.28626, 134.7612 +23264, 67.79093, 124.6467 +23265, 69.07817, 143.6054 +23266, 67.44134, 146.0127 +23267, 68.73085, 134.9284 +23268, 69.47641, 129.3397 +23269, 68.70536, 144.436 +23270, 64.93749, 106.7489 +23271, 67.24113, 111.1544 +23272, 66.56344, 131.8655 +23273, 65.53499, 94.12903 +23274, 63.90174, 118.1282 +23275, 69.67198, 133.5641 +23276, 64.43413, 124.1712 +23277, 64.51197, 115.5299 +23278, 67.70097, 133.1008 +23279, 64.90215, 123.7036 +23280, 67.99061, 129.6754 +23281, 67.82413, 120.6313 +23282, 68.52722, 126.7222 +23283, 69.2092, 121.3021 +23284, 66.20442, 115.7721 +23285, 71.109, 132.442 +23286, 68.57075, 114.2557 +23287, 68.00623, 137.8888 +23288, 64.09668, 113.0901 +23289, 68.75021, 138.3973 +23290, 65.47736, 116.194 +23291, 68.75545, 135.4326 +23292, 67.45601, 117.7914 +23293, 65.98877, 120.6623 +23294, 69.37016, 127.3013 +23295, 67.6734, 123.4882 +23296, 69.89525, 119.6832 +23297, 69.61509, 128.0375 +23298, 69.3937, 137.0006 +23299, 67.97247, 102.2394 +23300, 69.22724, 127.8642 +23301, 67.9542, 120.0739 +23302, 67.95068, 115.6076 +23303, 68.40984, 145.4263 +23304, 68.77759, 131.7281 +23305, 65.13204, 122.8043 +23306, 68.81528, 126.5719 +23307, 64.91737, 118.1884 +23308, 69.24, 141.1041 +23309, 64.37656, 106.7087 +23310, 66.94537, 128.9508 +23311, 67.93057, 122.6122 +23312, 67.94897, 110.6746 +23313, 67.85108, 123.105 +23314, 66.58719, 114.1358 +23315, 69.6734, 133.9095 +23316, 69.99226, 131.5353 +23317, 66.01009, 111.5487 +23318, 69.06337, 140.4059 +23319, 68.44652, 122.5025 +23320, 67.77966, 120.9614 +23321, 68.28074, 126.8558 +23322, 67.85813, 116.385 +23323, 66.32684, 104.7552 +23324, 64.69309, 116.3749 +23325, 69.99022, 153.7945 +23326, 71.14046, 139.3483 +23327, 73.11374, 141.5157 +23328, 67.07803, 128.1482 +23329, 67.86878, 111.8266 +23330, 66.00182, 122.9777 +23331, 66.90908, 135.2963 +23332, 66.6852, 127.4327 +23333, 67.09584, 138.9995 +23334, 69.32346, 129.5811 +23335, 71.51046, 152.7026 +23336, 67.95718, 126.8874 +23337, 71.95199, 148.9864 +23338, 64.63369, 101.6115 +23339, 67.76332, 102.2017 +23340, 67.47196, 128.7711 +23341, 68.9559, 128.348 +23342, 68.91935, 130.601 +23343, 69.72604, 129.9311 +23344, 69.36628, 126.0097 +23345, 69.36979, 160.0595 +23346, 70.82097, 125.9832 +23347, 67.88765, 130.1885 +23348, 66.24709, 108.1229 +23349, 65.29888, 126.1983 +23350, 68.06429, 115.6124 +23351, 68.31388, 157.1449 +23352, 66.80653, 129.4758 +23353, 70.76233, 128.8173 +23354, 67.91801, 131.1724 +23355, 67.7657, 137.7214 +23356, 68.41708, 129.1072 +23357, 70.60391, 134.6567 +23358, 70.95676, 152.5077 +23359, 67.80891, 119.3174 +23360, 68.05761, 144.4357 +23361, 71.64101, 137.6723 +23362, 69.56807, 131.7272 +23363, 68.37897, 124.4672 +23364, 69.52961, 139.0711 +23365, 67.91638, 129.7194 +23366, 65.90163, 130.2564 +23367, 66.40618, 120.6583 +23368, 66.75016, 127.253 +23369, 70.67254, 128.2802 +23370, 66.19564, 121.9578 +23371, 63.86903, 108.1252 +23372, 67.31392, 124.2722 +23373, 68.76809, 138.7117 +23374, 65.20943, 116.157 +23375, 66.98591, 115.0587 +23376, 67.42523, 136.1542 +23377, 66.50837, 120.1535 +23378, 67.6117, 121.1889 +23379, 66.61201, 121.5732 +23380, 70.86568, 118.6469 +23381, 71.32734, 128.9839 +23382, 65.4778, 112.1488 +23383, 67.97456, 143.301 +23384, 64.43034, 111.1606 +23385, 64.28602, 107.6355 +23386, 66.96798, 126.725 +23387, 70.1485, 131.5029 +23388, 69.33442, 151.3078 +23389, 64.16934, 112.0675 +23390, 68.13767, 119.5635 +23391, 67.08413, 112.2697 +23392, 67.41342, 121.7801 +23393, 66.12667, 114.907 +23394, 69.20029, 131.6151 +23395, 68.12415, 123.0866 +23396, 68.46751, 112.8145 +23397, 68.76315, 142.2609 +23398, 68.57141, 125.4749 +23399, 66.26613, 130.1712 +23400, 71.68987, 134.2174 +23401, 69.02855, 137.7087 +23402, 68.18153, 128.3747 +23403, 68.09645, 134.3938 +23404, 67.62189, 123.3117 +23405, 67.09138, 118.3389 +23406, 63.55618, 102.794 +23407, 62.85508, 114.4639 +23408, 68.7842, 131.0257 +23409, 63.50044, 120.7176 +23410, 67.44217, 134.7953 +23411, 67.98901, 129.3666 +23412, 70.35684, 147.6725 +23413, 69.72082, 128.5478 +23414, 64.46472, 100.3255 +23415, 67.97104, 130.713 +23416, 66.30166, 125.9627 +23417, 70.70031, 134.4612 +23418, 71.09133, 140.8249 +23419, 67.99134, 145.7668 +23420, 69.21008, 134.423 +23421, 66.88274, 126.4537 +23422, 68.36795, 125.8251 +23423, 68.49492, 134.5742 +23424, 68.58014, 153.277 +23425, 67.89223, 128.9499 +23426, 67.11189, 96.36193 +23427, 63.31715, 104.4658 +23428, 67.75509, 136.1973 +23429, 67.73474, 121.4205 +23430, 70.0064, 133.8839 +23431, 71.4794, 141.4209 +23432, 66.55546, 111.2872 +23433, 68.93126, 130.5566 +23434, 68.92078, 127.2883 +23435, 69.87076, 106.3125 +23436, 68.83485, 119.3079 +23437, 65.01842, 151.4337 +23438, 67.6557, 118.4406 +23439, 67.04163, 133.2765 +23440, 69.71126, 126.3546 +23441, 66.50183, 131.5315 +23442, 68.33511, 144.3527 +23443, 66.9407, 110.8551 +23444, 67.40925, 136.9725 +23445, 69.31165, 131.074 +23446, 64.06236, 115.105 +23447, 65.56181, 116.5971 +23448, 64.77319, 121.3992 +23449, 68.96452, 131.9731 +23450, 66.63747, 118.1281 +23451, 69.56752, 135.5865 +23452, 65.1007, 109.2654 +23453, 64.9936, 110.6938 +23454, 70.66323, 128.1262 +23455, 69.00077, 112.673 +23456, 70.10951, 114.8419 +23457, 67.34384, 114.9568 +23458, 68.60818, 134.9085 +23459, 67.23956, 107.1732 +23460, 72.29201, 139.9045 +23461, 67.08503, 120.075 +23462, 67.42026, 134.753 +23463, 69.11345, 124.4949 +23464, 72.35402, 138.0597 +23465, 65.26185, 121.3037 +23466, 68.44809, 119.1946 +23467, 63.33709, 129.6209 +23468, 69.63855, 127.8437 +23469, 70.94026, 120.1561 +23470, 68.87976, 129.9892 +23471, 66.86712, 117.3156 +23472, 71.04505, 130.1568 +23473, 68.38827, 119.0647 +23474, 67.52106, 122.7459 +23475, 69.87186, 132.0456 +23476, 71.55171, 117.5422 +23477, 66.46162, 127.9555 +23478, 72.02569, 124.1535 +23479, 67.57232, 118.5305 +23480, 69.00459, 120.4771 +23481, 65.95744, 133.5889 +23482, 69.42784, 138.1965 +23483, 66.84795, 110.233 +23484, 68.35329, 123.8493 +23485, 65.86502, 123.3062 +23486, 69.835, 140.2449 +23487, 67.66145, 126.0904 +23488, 68.19426, 144.2229 +23489, 69.32705, 129.9933 +23490, 67.61906, 116.2005 +23491, 73.40972, 133.009 +23492, 66.96963, 127.496 +23493, 66.12847, 105.4284 +23494, 67.31517, 123.035 +23495, 70.20341, 139.4022 +23496, 68.61279, 136.1018 +23497, 68.2315, 128.3552 +23498, 69.01795, 120.3067 +23499, 69.11662, 132.9447 +23500, 67.01546, 130.2632 +23501, 69.66929, 126.4905 +23502, 68.84648, 115.084 +23503, 68.62712, 120.257 +23504, 68.34286, 124.6374 +23505, 68.00429, 110.7882 +23506, 68.53424, 138.4216 +23507, 68.86421, 125.0711 +23508, 68.66789, 116.5181 +23509, 64.77087, 106.5228 +23510, 66.59801, 130.4351 +23511, 68.51877, 135.0892 +23512, 67.72455, 122.4271 +23513, 68.65578, 152.6253 +23514, 66.55626, 135.1086 +23515, 65.6087, 120.4908 +23516, 65.99372, 127.2212 +23517, 69.59156, 131.6555 +23518, 66.83509, 115.5445 +23519, 68.49693, 122.8879 +23520, 68.18592, 141.1364 +23521, 65.89922, 113.8338 +23522, 66.9475, 105.6898 +23523, 69.06182, 134.9376 +23524, 68.33972, 125.0717 +23525, 66.07267, 132.8536 +23526, 69.31936, 138.2366 +23527, 65.84808, 131.2502 +23528, 67.36294, 118.4514 +23529, 67.3593, 117.1267 +23530, 64.4803, 114.5619 +23531, 69.90125, 145.3534 +23532, 66.98612, 146.5458 +23533, 69.10503, 121.7325 +23534, 67.52838, 111.8378 +23535, 69.42915, 123.1078 +23536, 67.06781, 118.8862 +23537, 67.46411, 126.3954 +23538, 68.88653, 120.841 +23539, 67.0299, 111.8676 +23540, 64.80287, 122.305 +23541, 70.12057, 128.2378 +23542, 66.70331, 137.0292 +23543, 65.61686, 124.6061 +23544, 66.94092, 116.4586 +23545, 65.96306, 94.7257 +23546, 65.67991, 123.1875 +23547, 69.71521, 131.7122 +23548, 72.27532, 154.9474 +23549, 68.9462, 125.8252 +23550, 65.77925, 120.1731 +23551, 67.74371, 133.4557 +23552, 67.50658, 138.89 +23553, 64.7387, 129.9819 +23554, 70.40075, 138.2906 +23555, 66.31113, 118.736 +23556, 69.07813, 132.6275 +23557, 65.591, 118.3107 +23558, 67.68762, 120.8594 +23559, 66.44951, 120.1558 +23560, 68.08673, 126.8226 +23561, 66.24786, 127.0943 +23562, 70.99353, 123.479 +23563, 68.2099, 127.1802 +23564, 67.95421, 125.725 +23565, 68.83812, 129.5121 +23566, 65.96009, 128.081 +23567, 66.27192, 118.0759 +23568, 65.97624, 115.5401 +23569, 66.75536, 121.1873 +23570, 70.71061, 142.0151 +23571, 69.7805, 121.0935 +23572, 68.54296, 139.0712 +23573, 68.1192, 108.6708 +23574, 65.3068, 129.9528 +23575, 69.78927, 139.6959 +23576, 68.62776, 126.7958 +23577, 70.62247, 130.7473 +23578, 68.90663, 139.9702 +23579, 69.10172, 147.4603 +23580, 65.38912, 106.2248 +23581, 67.42929, 118.2165 +23582, 68.36866, 129.2801 +23583, 68.36248, 120.0642 +23584, 66.87574, 122.173 +23585, 69.29149, 127.6393 +23586, 65.28542, 129.8255 +23587, 66.6047, 119.5932 +23588, 66.85857, 137.179 +23589, 71.25571, 140.6042 +23590, 70.01811, 125.5674 +23591, 68.14057, 121.5594 +23592, 70.42527, 136.4209 +23593, 70.19124, 116.1543 +23594, 70.03089, 121.4123 +23595, 66.38573, 126.3671 +23596, 66.9214, 125.7389 +23597, 67.42805, 135.3317 +23598, 67.65681, 110.0211 +23599, 67.35105, 110.7792 +23600, 66.64091, 119.5543 +23601, 69.83869, 146.7883 +23602, 66.59553, 124.4923 +23603, 69.77893, 122.8878 +23604, 66.08192, 128.2059 +23605, 70.75962, 145.1159 +23606, 68.33049, 109.8427 +23607, 67.25612, 139.0113 +23608, 70.61119, 143.3182 +23609, 67.56781, 112.6521 +23610, 70.97495, 148.0819 +23611, 70.12654, 129.6234 +23612, 68.78941, 128.9925 +23613, 67.18784, 110.9939 +23614, 67.1599, 121.0722 +23615, 67.87817, 132.0587 +23616, 69.82444, 124.1746 +23617, 68.68474, 116.2746 +23618, 69.35291, 130.007 +23619, 68.57852, 135.4695 +23620, 67.33814, 133.6925 +23621, 68.19909, 124.0152 +23622, 63.92008, 113.4979 +23623, 68.02589, 121.0372 +23624, 66.5546, 127.0069 +23625, 67.95995, 112.8356 +23626, 67.45313, 138.8983 +23627, 69.72472, 146.8345 +23628, 65.79407, 117.257 +23629, 68.77865, 148.2023 +23630, 65.47726, 110.3392 +23631, 68.95735, 124.7896 +23632, 68.41169, 137.9051 +23633, 67.62647, 134.5912 +23634, 66.45056, 136.37 +23635, 68.41418, 136.993 +23636, 73.46216, 140.968 +23637, 65.43572, 118.0352 +23638, 67.99082, 135.9919 +23639, 67.52665, 122.5461 +23640, 67.73934, 115.2443 +23641, 65.96595, 119.5018 +23642, 68.87961, 121.7995 +23643, 68.08036, 127.2558 +23644, 67.36171, 120.6458 +23645, 64.38354, 119.3323 +23646, 69.75639, 126.066 +23647, 66.8137, 106.6755 +23648, 67.46087, 121.3847 +23649, 68.99738, 118.3578 +23650, 66.52827, 123.3633 +23651, 69.43908, 136.248 +23652, 67.88492, 122.1517 +23653, 70.61052, 147.686 +23654, 69.48816, 130.5616 +23655, 67.12804, 122.7826 +23656, 67.75649, 117.9294 +23657, 70.94686, 131.9377 +23658, 68.2358, 125.9982 +23659, 68.81174, 135.5761 +23660, 69.37167, 130.0714 +23661, 66.56234, 123.6984 +23662, 67.51121, 115.6791 +23663, 67.92882, 129.482 +23664, 64.63454, 109.9452 +23665, 67.79166, 118.3516 +23666, 67.04792, 125.6464 +23667, 68.56413, 112.2504 +23668, 67.53116, 124.9106 +23669, 67.71164, 130.67 +23670, 71.49767, 128.9497 +23671, 66.42399, 121.8209 +23672, 65.25687, 115.1695 +23673, 67.02666, 121.5475 +23674, 68.4504, 122.1388 +23675, 73.55566, 149.8402 +23676, 69.17741, 131.2888 +23677, 67.4203, 110.133 +23678, 67.42349, 130.7954 +23679, 70.42099, 127.0184 +23680, 67.02709, 116.7578 +23681, 66.33083, 129.3366 +23682, 69.55259, 133.0437 +23683, 69.55744, 135.4041 +23684, 67.25328, 138.7002 +23685, 66.1666, 105.7041 +23686, 68.87957, 98.57059 +23687, 69.62485, 131.5031 +23688, 68.47403, 129.3925 +23689, 65.07886, 140.2449 +23690, 67.07668, 137.308 +23691, 65.87754, 121.0767 +23692, 68.13293, 123.9844 +23693, 70.14968, 121.9132 +23694, 65.34486, 111.9794 +23695, 66.07233, 123.6313 +23696, 68.10652, 129.6434 +23697, 71.04529, 139.779 +23698, 64.75341, 119.3351 +23699, 67.33457, 110.3688 +23700, 64.26607, 127.348 +23701, 66.25028, 122.8633 +23702, 69.80613, 126.2564 +23703, 70.31933, 132.2946 +23704, 65.90373, 122.0525 +23705, 68.12881, 111.4134 +23706, 69.43281, 120.0944 +23707, 69.05555, 140.1024 +23708, 70.16747, 139.4727 +23709, 70.72975, 152.7356 +23710, 69.50996, 137.1134 +23711, 67.74268, 136.3711 +23712, 67.58253, 128.0786 +23713, 65.01312, 125.7965 +23714, 67.06595, 129.959 +23715, 68.32618, 129.2915 +23716, 67.4883, 132.394 +23717, 67.81802, 121.1499 +23718, 67.86423, 122.2616 +23719, 67.04793, 144.7241 +23720, 69.56793, 124.4291 +23721, 64.52939, 128.9372 +23722, 68.42798, 122.4175 +23723, 68.71113, 112.1148 +23724, 66.14989, 138.2484 +23725, 72.84817, 151.3727 +23726, 71.75528, 136.2952 +23727, 66.20062, 122.2395 +23728, 71.30122, 122.1991 +23729, 72.70475, 106.6605 +23730, 66.4848, 131.0492 +23731, 65.73936, 103.8932 +23732, 65.73932, 116.6705 +23733, 68.36851, 126.187 +23734, 66.78073, 123.7823 +23735, 65.25826, 95.63814 +23736, 69.25203, 125.6851 +23737, 68.19473, 113.3283 +23738, 67.42308, 127.9037 +23739, 68.59131, 121.6313 +23740, 69.93451, 112.2096 +23741, 68.35495, 137.9728 +23742, 67.77473, 133.3277 +23743, 70.20824, 136.6606 +23744, 64.81088, 111.9485 +23745, 70.52361, 135.5258 +23746, 68.65188, 115.0439 +23747, 67.0511, 131.1182 +23748, 69.31371, 132.4638 +23749, 67.36956, 128.4464 +23750, 70.15169, 114.8211 +23751, 65.51921, 113.3363 +23752, 70.00466, 104.466 +23753, 68.0189, 129.3333 +23754, 66.72787, 103.2365 +23755, 69.81422, 132.2248 +23756, 67.4484, 105.256 +23757, 64.50036, 126.8106 +23758, 67.42181, 127.379 +23759, 69.54484, 135.6098 +23760, 66.78251, 94.51209 +23761, 68.02583, 135.0232 +23762, 69.59756, 126.0523 +23763, 69.70111, 147.8201 +23764, 68.69898, 131.2838 +23765, 69.50665, 139.9177 +23766, 67.16676, 125.2779 +23767, 66.01105, 130.5078 +23768, 68.95166, 129.3768 +23769, 68.38876, 119.2589 +23770, 67.47329, 132.4444 +23771, 66.73831, 128.1593 +23772, 64.92467, 96.91718 +23773, 71.2568, 130.6852 +23774, 68.64395, 136.5972 +23775, 67.67603, 124.4685 +23776, 65.50539, 143.9237 +23777, 64.31386, 119.0699 +23778, 69.72695, 119.3308 +23779, 65.11523, 125.7234 +23780, 63.70715, 111.0903 +23781, 69.94478, 128.5573 +23782, 67.20119, 113.6719 +23783, 71.38651, 141.1154 +23784, 66.74038, 133.1715 +23785, 65.21928, 125.0902 +23786, 66.83913, 129.4363 +23787, 69.02398, 130.9462 +23788, 67.32826, 112.6738 +23789, 66.59493, 127.1637 +23790, 71.73466, 145.4267 +23791, 66.33824, 123.3295 +23792, 67.0491, 123.2213 +23793, 70.64134, 152.056 +23794, 69.59606, 118.9768 +23795, 66.78068, 119.4823 +23796, 69.39063, 149.617 +23797, 69.90303, 133.9469 +23798, 72.73727, 144.2981 +23799, 68.39263, 132.5303 +23800, 68.31048, 129.9349 +23801, 66.94796, 113.807 +23802, 68.97424, 131.1916 +23803, 63.82304, 120.9811 +23804, 67.42872, 134.8411 +23805, 67.44922, 122.6827 +23806, 68.4922, 143.6419 +23807, 65.45648, 99.10252 +23808, 67.46239, 125.3729 +23809, 68.06118, 119.3436 +23810, 69.35205, 127.3954 +23811, 67.1694, 120.7452 +23812, 69.16451, 138.1299 +23813, 67.84407, 117.4335 +23814, 69.74531, 136.4161 +23815, 69.50049, 118.8787 +23816, 65.59756, 109.2654 +23817, 65.7887, 121.8958 +23818, 67.73988, 121.1281 +23819, 67.45264, 107.8988 +23820, 66.76519, 118.5142 +23821, 69.16573, 122.5451 +23822, 67.64803, 130.9586 +23823, 68.99719, 126.3192 +23824, 66.95571, 114.573 +23825, 68.21681, 139.3253 +23826, 70.59044, 135.6509 +23827, 67.01016, 136.7692 +23828, 67.16363, 112.0325 +23829, 67.31394, 114.5343 +23830, 68.61835, 135.0315 +23831, 67.52474, 129.9562 +23832, 68.7303, 132.5218 +23833, 68.51045, 113.1181 +23834, 70.2755, 124.5574 +23835, 69.58278, 132.3214 +23836, 68.17009, 126.5205 +23837, 68.29276, 130.0106 +23838, 69.6923, 140.5433 +23839, 70.30843, 136.5605 +23840, 65.24029, 116.5097 +23841, 71.56487, 132.1166 +23842, 67.86942, 130.7553 +23843, 67.8101, 144.9624 +23844, 66.69452, 119.4778 +23845, 68.80517, 129.8844 +23846, 67.00182, 134.3311 +23847, 68.36228, 144.5173 +23848, 70.3389, 131.5169 +23849, 68.009, 126.9959 +23850, 65.48455, 136.5241 +23851, 69.68966, 125.4997 +23852, 68.552, 129.4829 +23853, 68.2096, 138.6158 +23854, 66.93118, 121.261 +23855, 67.46192, 119.6095 +23856, 69.29621, 107.5141 +23857, 68.12627, 130.5966 +23858, 66.35397, 124.3943 +23859, 68.31918, 120.5494 +23860, 67.79233, 119.2799 +23861, 66.99949, 124.8734 +23862, 69.77773, 131.3978 +23863, 69.52365, 147.8093 +23864, 66.95733, 129.7038 +23865, 68.37534, 117.5037 +23866, 67.07925, 137.0927 +23867, 64.60565, 98.9372 +23868, 66.65496, 139.758 +23869, 69.01472, 121.4022 +23870, 66.8597, 122.6126 +23871, 69.87952, 144.0689 +23872, 64.61346, 103.4199 +23873, 67.75415, 134.9398 +23874, 73.02684, 139.7916 +23875, 68.15447, 128.9553 +23876, 72.59702, 136.8067 +23877, 68.01914, 112.0903 +23878, 65.82187, 112.6344 +23879, 68.81957, 130.1162 +23880, 71.317, 144.7312 +23881, 70.00255, 137.785 +23882, 66.38261, 122.7683 +23883, 68.21355, 140.6809 +23884, 67.74003, 108.2607 +23885, 70.18718, 122.1478 +23886, 71.83265, 130.342 +23887, 67.36621, 116.9097 +23888, 68.57086, 135.0217 +23889, 71.04741, 151.1236 +23890, 66.59795, 123.6365 +23891, 68.81107, 118.8078 +23892, 65.33076, 116.2683 +23893, 68.52512, 129.2716 +23894, 68.01263, 133.3037 +23895, 68.81095, 129.318 +23896, 71.415, 142.9992 +23897, 73.38057, 154.3189 +23898, 69.0571, 127.9148 +23899, 66.30593, 125.7792 +23900, 67.19635, 120.2431 +23901, 66.82731, 118.848 +23902, 70.80376, 131.1233 +23903, 69.21079, 126.0975 +23904, 68.97666, 140.9174 +23905, 70.93475, 141 +23906, 69.29018, 137.2974 +23907, 67.88454, 132.3025 +23908, 68.839, 139.0026 +23909, 68.75738, 128.0374 +23910, 66.63057, 118.8852 +23911, 68.70439, 122.1627 +23912, 70.42439, 142.969 +23913, 68.09534, 120.9784 +23914, 68.73448, 155.5583 +23915, 66.32387, 126.5144 +23916, 68.38525, 133.0024 +23917, 71.26558, 129.0136 +23918, 70.30804, 139.5592 +23919, 72.37914, 125.4124 +23920, 70.68229, 145.6807 +23921, 69.25524, 116.9842 +23922, 68.61717, 118.0604 +23923, 69.95234, 154.2652 +23924, 67.21192, 122.616 +23925, 68.95803, 140.1877 +23926, 70.21225, 115.701 +23927, 66.06475, 117.0679 +23928, 69.89075, 153.5111 +23929, 65.70868, 118.8838 +23930, 67.40897, 131.353 +23931, 67.80336, 128.5892 +23932, 66.77537, 126.0811 +23933, 69.39472, 124.5088 +23934, 68.03254, 152.3259 +23935, 70.68853, 142.0573 +23936, 64.90623, 125.4661 +23937, 66.7301, 124.653 +23938, 66.05134, 125.7801 +23939, 65.12063, 107.4916 +23940, 70.73337, 136.9526 +23941, 70.21345, 129.7068 +23942, 67.41542, 144.5605 +23943, 69.81576, 121.2493 +23944, 69.08556, 124.4855 +23945, 68.79164, 125.9361 +23946, 64.48761, 124.4471 +23947, 65.63039, 122.1341 +23948, 63.8873, 101.9472 +23949, 64.23075, 110.6193 +23950, 68.96118, 138.7769 +23951, 67.28415, 117.8188 +23952, 67.95165, 129.1463 +23953, 66.13126, 121.0599 +23954, 69.68175, 125.9135 +23955, 68.97307, 132.694 +23956, 68.54922, 140.4031 +23957, 72.05551, 144.0404 +23958, 69.71957, 127.4787 +23959, 66.86686, 144.6107 +23960, 68.5857, 132.7412 +23961, 67.71756, 150.1169 +23962, 69.84981, 115.8517 +23963, 70.80466, 148.1321 +23964, 69.82289, 136.5182 +23965, 68.44916, 118.8654 +23966, 64.51651, 124.292 +23967, 66.39716, 102.9907 +23968, 70.74389, 119.446 +23969, 68.03206, 126.3614 +23970, 70.51117, 146.8083 +23971, 68.10873, 141.6847 +23972, 67.23845, 115.9517 +23973, 68.54145, 146.4722 +23974, 66.88341, 120.6493 +23975, 67.94309, 127.9486 +23976, 70.47829, 140.5446 +23977, 67.41672, 103.9911 +23978, 71.68845, 138.8903 +23979, 68.42777, 132.1107 +23980, 69.80496, 139.5662 +23981, 69.95499, 123.728 +23982, 66.12776, 129.0935 +23983, 66.77574, 104.4298 +23984, 68.88634, 146.4716 +23985, 66.04019, 122.0205 +23986, 66.82725, 105.2155 +23987, 71.84956, 114.3322 +23988, 66.5493, 120.0294 +23989, 66.64194, 122.2388 +23990, 69.40514, 125.8462 +23991, 68.9732, 149.142 +23992, 68.89927, 118.6997 +23993, 66.49234, 114.5492 +23994, 69.66246, 123.1604 +23995, 71.37386, 119.0819 +23996, 68.49401, 128.6116 +23997, 66.74375, 116.3968 +23998, 68.17463, 136.3225 +23999, 66.44601, 109.0425 +24000, 66.93173, 127.6166 +24001, 71.05722, 129.2659 +24002, 70.44551, 132.4324 +24003, 66.78778, 123.2117 +24004, 66.99974, 104.313 +24005, 66.93056, 129.3818 +24006, 68.64546, 156.5212 +24007, 68.33571, 116.6739 +24008, 67.13465, 131.0346 +24009, 66.99755, 137.65 +24010, 66.55502, 109.5773 +24011, 67.6653, 118.1356 +24012, 68.29447, 121.9493 +24013, 67.86169, 136.1423 +24014, 65.99617, 123.9677 +24015, 69.31348, 126.5029 +24016, 66.8696, 128.1357 +24017, 67.89663, 111.9666 +24018, 68.59532, 132.2773 +24019, 65.47889, 119.7798 +24020, 65.17519, 122.6844 +24021, 69.09782, 121.3777 +24022, 68.59388, 135.8185 +24023, 67.38888, 107.0327 +24024, 67.39861, 148.6724 +24025, 67.55792, 118.6378 +24026, 68.62413, 135.944 +24027, 68.57569, 143.4643 +24028, 69.64614, 139.2707 +24029, 70.87591, 153.1772 +24030, 66.54682, 120.1556 +24031, 66.75683, 122.6771 +24032, 69.0924, 132.2348 +24033, 66.26872, 125.055 +24034, 70.44345, 129.744 +24035, 65.63798, 100.8841 +24036, 66.14059, 125.2816 +24037, 69.02744, 116.3008 +24038, 69.11634, 135.7018 +24039, 66.91189, 124.487 +24040, 67.47984, 118.6579 +24041, 66.27411, 142.8314 +24042, 69.06754, 133.5337 +24043, 68.74367, 113.0626 +24044, 67.78497, 123.231 +24045, 66.80328, 121.5905 +24046, 67.49976, 125.0247 +24047, 65.05186, 123.9833 +24048, 69.20162, 105.2719 +24049, 69.61355, 124.7545 +24050, 70.41472, 130.2035 +24051, 62.91894, 121.8655 +24052, 69.06546, 125.3295 +24053, 68.80458, 123.1664 +24054, 67.55559, 144.891 +24055, 69.75067, 136.7792 +24056, 68.04394, 129.1908 +24057, 70.18295, 107.8295 +24058, 68.99489, 141.8741 +24059, 67.51961, 128.5576 +24060, 64.56646, 119.602 +24061, 71.95831, 135.2597 +24062, 69.0224, 144.1056 +24063, 66.51118, 122.3771 +24064, 67.9872, 121.1185 +24065, 67.45834, 111.0184 +24066, 67.4141, 136.7198 +24067, 65.22365, 112.0242 +24068, 69.31591, 142.3476 +24069, 69.34287, 135.2131 +24070, 68.50494, 143.4556 +24071, 70.94343, 137.6151 +24072, 69.26483, 122.2489 +24073, 64.8763, 111.4897 +24074, 67.3401, 121.8431 +24075, 65.85647, 117.6178 +24076, 68.28513, 129.4322 +24077, 71.49848, 135.5103 +24078, 68.14922, 125.2074 +24079, 73.22107, 136.736 +24080, 70.24483, 136.0741 +24081, 66.16476, 119.8647 +24082, 70.72408, 150.4398 +24083, 69.60885, 126.7483 +24084, 68.64307, 131.2725 +24085, 70.82908, 121.2912 +24086, 66.17383, 112.7295 +24087, 68.54875, 138.1077 +24088, 67.97518, 116.8066 +24089, 68.32635, 125.2183 +24090, 72.05565, 127.6232 +24091, 67.94268, 124.3097 +24092, 67.72877, 119.0444 +24093, 69.59699, 126.4719 +24094, 70.84343, 130.0128 +24095, 71.14967, 139.4641 +24096, 66.78035, 112.8561 +24097, 67.51289, 128.4778 +24098, 69.2969, 129.867 +24099, 68.04596, 113.2546 +24100, 66.49564, 127.5542 +24101, 71.87029, 151.8397 +24102, 68.3905, 132.1402 +24103, 65.00438, 113.921 +24104, 66.20503, 120.4717 +24105, 69.34408, 126.0365 +24106, 67.73769, 116.4037 +24107, 68.95293, 120.5159 +24108, 67.79797, 141.8728 +24109, 66.26302, 130.6336 +24110, 69.71346, 122.8188 +24111, 67.72305, 96.06788 +24112, 66.72756, 123.1148 +24113, 66.75114, 132.4506 +24114, 66.96514, 142.6672 +24115, 67.59748, 106.3744 +24116, 65.51196, 135.7343 +24117, 68.93433, 118.4039 +24118, 70.04973, 139.9917 +24119, 68.57453, 142.7562 +24120, 69.95846, 133.5556 +24121, 69.67227, 144.783 +24122, 67.48895, 121.146 +24123, 68.41794, 127.0591 +24124, 70.64777, 141.8289 +24125, 68.74365, 118.5769 +24126, 67.49912, 134.2321 +24127, 68.96778, 118.3576 +24128, 64.27649, 115.885 +24129, 69.76465, 126.8942 +24130, 68.8062, 140.9144 +24131, 69.53558, 118.5909 +24132, 66.76818, 117.2523 +24133, 70.02343, 144.426 +24134, 65.68234, 114.9949 +24135, 63.5547, 103.4864 +24136, 64.35694, 116.7422 +24137, 67.86944, 104.8291 +24138, 64.26485, 116.6974 +24139, 70.98567, 136.3881 +24140, 68.02723, 129.2539 +24141, 65.82659, 125.2597 +24142, 69.30638, 124.229 +24143, 66.25985, 138.3646 +24144, 67.35007, 121.1851 +24145, 70.33575, 156.0098 +24146, 69.03953, 128.1108 +24147, 69.32626, 140.6029 +24148, 67.11686, 121.2675 +24149, 67.96735, 143.4441 +24150, 70.20798, 128.3993 +24151, 69.09575, 132.1344 +24152, 67.32842, 130.276 +24153, 67.57214, 126.6289 +24154, 67.48418, 121.5747 +24155, 67.43897, 142.602 +24156, 70.60461, 136.0619 +24157, 69.67131, 116.3116 +24158, 68.79333, 134.0923 +24159, 68.6349, 140.4769 +24160, 66.747, 128.7257 +24161, 67.88882, 140.7871 +24162, 67.2596, 125.8938 +24163, 66.72282, 117.8449 +24164, 63.72796, 108.0979 +24165, 67.57522, 128.0214 +24166, 69.42324, 139.5001 +24167, 67.42113, 128.4317 +24168, 69.55405, 128.6576 +24169, 68.10755, 136.0476 +24170, 70.91036, 135.1862 +24171, 67.535, 117.3195 +24172, 68.98823, 132.1382 +24173, 65.828, 135.4497 +24174, 64.87945, 124.8061 +24175, 68.02627, 133.2315 +24176, 66.48368, 129.5454 +24177, 68.02029, 114.874 +24178, 69.4901, 125.2642 +24179, 69.58713, 127.6308 +24180, 70.01705, 128.6734 +24181, 68.28885, 134.9464 +24182, 68.65246, 128.2972 +24183, 65.70769, 129.3739 +24184, 70.41426, 133.9713 +24185, 66.89627, 114.3175 +24186, 69.1823, 133.4793 +24187, 68.80486, 137.2361 +24188, 69.21155, 161.8504 +24189, 64.35037, 111.6101 +24190, 70.26517, 134.1679 +24191, 69.56064, 122.5547 +24192, 65.5203, 120.5505 +24193, 69.15769, 123.7836 +24194, 69.66405, 138.799 +24195, 67.44392, 131.769 +24196, 67.8289, 148.232 +24197, 69.59938, 131.8266 +24198, 67.51364, 115.2855 +24199, 73.03159, 139.2101 +24200, 64.51111, 118.8058 +24201, 69.88715, 147.5768 +24202, 71.0594, 128.6246 +24203, 66.13664, 118.9781 +24204, 68.92441, 147.0122 +24205, 69.72196, 139.1363 +24206, 68.76197, 132.05 +24207, 70.53243, 127.2087 +24208, 66.13778, 113.9093 +24209, 67.43917, 125.6656 +24210, 65.85657, 133.1832 +24211, 67.41715, 126.6363 +24212, 68.04343, 114.9553 +24213, 67.46147, 140.3633 +24214, 71.45905, 139.5134 +24215, 70.03432, 136.4678 +24216, 66.67824, 137.1923 +24217, 69.72584, 123.3291 +24218, 68.9367, 119.3911 +24219, 69.55646, 131.0409 +24220, 68.60903, 127.2278 +24221, 66.65147, 129.0941 +24222, 69.74899, 132.0704 +24223, 66.28759, 103.6524 +24224, 65.4048, 121.4187 +24225, 67.43504, 125.4301 +24226, 66.8601, 111.9679 +24227, 67.42077, 104.6335 +24228, 66.83403, 98.53013 +24229, 67.45638, 109.922 +24230, 68.39069, 127.7844 +24231, 68.10474, 122.7165 +24232, 67.35962, 116.7826 +24233, 67.93121, 117.5358 +24234, 69.00845, 137.3313 +24235, 66.98731, 126.8991 +24236, 69.13794, 142.4036 +24237, 69.79289, 119.0381 +24238, 68.63362, 128.3377 +24239, 65.68681, 133.8128 +24240, 68.03586, 139.3538 +24241, 68.56161, 115.2544 +24242, 65.31821, 130.3495 +24243, 67.54969, 115.5331 +24244, 64.9513, 110.3166 +24245, 62.26498, 104.1348 +24246, 67.05169, 142.0848 +24247, 69.42594, 132.518 +24248, 66.76908, 121.5039 +24249, 67.59811, 134.4056 +24250, 67.74663, 126.3347 +24251, 68.95289, 137.2302 +24252, 70.92726, 140.5278 +24253, 67.5076, 131.3532 +24254, 68.09779, 133.6869 +24255, 66.72497, 130.3382 +24256, 68.17851, 130.9928 +24257, 69.70107, 148.6245 +24258, 69.81542, 140.4349 +24259, 69.17806, 114.3901 +24260, 67.5213, 106.7127 +24261, 65.07932, 126.1848 +24262, 65.76272, 118.194 +24263, 67.38848, 120.523 +24264, 66.55762, 128.3819 +24265, 69.23117, 139.317 +24266, 67.97129, 137.9738 +24267, 68.50282, 132.3038 +24268, 66.11285, 129.8084 +24269, 68.29893, 119.2646 +24270, 66.43765, 114.2571 +24271, 69.81484, 148.605 +24272, 70.8647, 148.6468 +24273, 70.65, 124.5929 +24274, 66.3832, 117.1383 +24275, 65.39059, 138.0883 +24276, 63.60936, 119.2431 +24277, 68.41909, 139.949 +24278, 67.5536, 140.8926 +24279, 67.57167, 127.7977 +24280, 69.75543, 134.612 +24281, 65.97912, 115.7997 +24282, 69.82973, 127.4906 +24283, 68.25923, 137.5393 +24284, 68.52437, 123.8685 +24285, 67.44386, 120.3718 +24286, 68.81971, 121.4659 +24287, 67.6395, 106.6431 +24288, 67.13938, 121.3981 +24289, 67.68633, 128.4577 +24290, 67.06687, 123.2179 +24291, 65.7778, 127.2213 +24292, 65.89887, 119.1833 +24293, 67.07721, 131.6767 +24294, 71.12368, 141.4488 +24295, 69.35961, 137.6262 +24296, 69.07129, 131.0639 +24297, 68.52627, 136.7567 +24298, 67.1445, 128.2922 +24299, 67.88215, 113.533 +24300, 64.0373, 100.1102 +24301, 67.57486, 136.41 +24302, 69.77337, 135.0577 +24303, 68.60777, 148.6195 +24304, 64.55533, 121.8647 +24305, 66.06962, 116.8535 +24306, 67.95484, 136.1466 +24307, 67.37979, 124.2873 +24308, 67.90461, 136.9687 +24309, 69.82622, 114.3628 +24310, 66.25075, 123.4614 +24311, 67.49232, 125.4319 +24312, 68.89903, 138.7552 +24313, 68.22911, 148.3492 +24314, 67.01689, 121.5691 +24315, 70.22735, 135.4663 +24316, 66.58757, 133.0016 +24317, 70.5615, 148.0778 +24318, 68.93279, 117.798 +24319, 69.06889, 150.3723 +24320, 68.51969, 125.8678 +24321, 64.25367, 126.0578 +24322, 71.94301, 139.7416 +24323, 70.01068, 129.4594 +24324, 69.18761, 129.8031 +24325, 69.14814, 132.6303 +24326, 67.04657, 127.9961 +24327, 71.45121, 147.6741 +24328, 64.21518, 119.9798 +24329, 69.94629, 135.4905 +24330, 70.26145, 132.4525 +24331, 69.17309, 132.7108 +24332, 67.97198, 130.1606 +24333, 66.57066, 131.3612 +24334, 69.86779, 115.1897 +24335, 66.85479, 97.71783 +24336, 69.74719, 126.6111 +24337, 65.94489, 132.2651 +24338, 65.87931, 103.3388 +24339, 64.62128, 101.6749 +24340, 68.54834, 130.3597 +24341, 67.92111, 123.939 +24342, 67.67285, 112.4801 +24343, 69.00279, 127.8311 +24344, 70.04797, 126.3484 +24345, 71.35258, 142.3712 +24346, 71.06775, 136.8046 +24347, 68.82243, 124.1371 +24348, 67.96857, 118.8369 +24349, 68.05889, 124.9371 +24350, 67.93692, 130.9467 +24351, 69.45398, 127.8837 +24352, 71.28182, 145.4692 +24353, 67.69446, 134.3376 +24354, 71.04547, 140.9563 +24355, 67.17175, 130.1958 +24356, 67.73543, 135.5123 +24357, 68.89435, 149.0303 +24358, 68.96831, 135.7274 +24359, 68.46784, 123.8383 +24360, 69.39747, 136.1145 +24361, 68.49673, 133.4028 +24362, 64.99401, 109.1885 +24363, 67.55392, 109.8925 +24364, 66.39846, 135.3121 +24365, 68.87766, 124.4382 +24366, 68.08728, 115.4819 +24367, 67.6748, 113.0279 +24368, 68.36341, 116.9069 +24369, 66.15639, 112.2191 +24370, 69.94863, 138.7619 +24371, 68.68161, 123.382 +24372, 65.57366, 108.7335 +24373, 67.47088, 124.634 +24374, 65.41412, 126.6553 +24375, 66.94215, 120.7258 +24376, 67.65712, 128.6122 +24377, 64.65079, 128.6303 +24378, 69.62877, 134.5557 +24379, 68.3735, 96.55141 +24380, 70.59634, 122.2144 +24381, 65.95534, 121.6048 +24382, 66.77646, 124.7321 +24383, 68.33367, 112.2217 +24384, 65.34891, 114.194 +24385, 70.0911, 138.6245 +24386, 66.96985, 128.6963 +24387, 69.5545, 109.8168 +24388, 68.5107, 136.2548 +24389, 67.75916, 114.7828 +24390, 67.28528, 156.6534 +24391, 69.10551, 135.7604 +24392, 70.04724, 118.1827 +24393, 67.97214, 130.4773 +24394, 64.98386, 100.1129 +24395, 67.57048, 125.9502 +24396, 65.91465, 107.5697 +24397, 70.47111, 140.7773 +24398, 67.52349, 126.2727 +24399, 68.45395, 134.877 +24400, 67.41775, 106.1401 +24401, 67.70655, 136.4734 +24402, 71.462, 148.1379 +24403, 66.73324, 128.8244 +24404, 64.50386, 105.9096 +24405, 69.11294, 127.3691 +24406, 69.38115, 129.7479 +24407, 68.33484, 127.2209 +24408, 69.29735, 126.0557 +24409, 68.37994, 135.6956 +24410, 68.96454, 134.9102 +24411, 70.49134, 133.6584 +24412, 70.57015, 134.172 +24413, 66.48853, 115.3811 +24414, 69.71507, 131.6692 +24415, 69.58669, 137.2034 +24416, 68.9727, 121.9887 +24417, 68.12075, 121.0738 +24418, 69.27581, 127.1409 +24419, 66.76377, 123.5561 +24420, 67.67916, 124.3837 +24421, 66.03738, 141.5574 +24422, 67.83577, 134.7204 +24423, 68.4144, 124.3957 +24424, 67.89829, 116.7193 +24425, 70.43392, 140.3597 +24426, 69.20164, 133.9186 +24427, 68.95842, 134.4443 +24428, 68.42838, 125.6241 +24429, 70.98873, 151.5456 +24430, 67.32737, 144.3687 +24431, 68.48893, 108.1511 +24432, 68.6021, 113.2208 +24433, 68.81368, 123.9034 +24434, 70.77293, 125.3918 +24435, 64.76018, 123.5229 +24436, 69.93755, 131.4882 +24437, 66.73936, 136.6536 +24438, 69.99554, 140.237 +24439, 69.93809, 139.2643 +24440, 68.76645, 140.7663 +24441, 65.93075, 122.8422 +24442, 65.71357, 110.0107 +24443, 69.81803, 135.7896 +24444, 65.60202, 122.6465 +24445, 69.04719, 110.6967 +24446, 71.79083, 116.5191 +24447, 65.47357, 130.9999 +24448, 68.56939, 121.2454 +24449, 67.3586, 113.1476 +24450, 69.31713, 118.5719 +24451, 68.04311, 140.9153 +24452, 70.58559, 140.6903 +24453, 65.81808, 116.2507 +24454, 69.49135, 130.3794 +24455, 67.24822, 121.8022 +24456, 67.92553, 126.7836 +24457, 70.37417, 153.1035 +24458, 67.27196, 126.1286 +24459, 71.48238, 143.7516 +24460, 68.10255, 137.9851 +24461, 67.81752, 114.8164 +24462, 64.53079, 100.9189 +24463, 66.93004, 122.4382 +24464, 67.74549, 128.7442 +24465, 69.06341, 144.9266 +24466, 68.05135, 131.0403 +24467, 65.22274, 113.4175 +24468, 70.59627, 132.1285 +24469, 66.67924, 123.53 +24470, 67.09362, 112.9607 +24471, 67.34935, 132.3745 +24472, 68.25905, 117.2967 +24473, 71.51413, 141.4801 +24474, 69.19176, 136.2781 +24475, 68.85149, 119.5382 +24476, 62.68591, 118.6002 +24477, 68.93339, 126.4631 +24478, 66.81582, 131.0701 +24479, 68.82523, 119.6506 +24480, 67.79889, 111.5895 +24481, 70.56176, 131.7029 +24482, 63.76528, 109.2093 +24483, 68.69047, 123.393 +24484, 68.5612, 133.2161 +24485, 65.9104, 135.1969 +24486, 69.50434, 154.9778 +24487, 67.01715, 103.3397 +24488, 67.42555, 112.6464 +24489, 69.80123, 123.7655 +24490, 69.35558, 142.1629 +24491, 69.40991, 134.6446 +24492, 68.14932, 124.156 +24493, 67.49197, 136.9491 +24494, 67.83128, 116.3515 +24495, 66.88311, 136.024 +24496, 66.16765, 112.1413 +24497, 68.34192, 148.7264 +24498, 68.47918, 115.6665 +24499, 64.1332, 126.2502 +24500, 69.76909, 137.5824 +24501, 67.87052, 128.4015 +24502, 65.65317, 122.6266 +24503, 69.10982, 127.845 +24504, 70.2136, 146.6532 +24505, 68.12511, 116.4182 +24506, 69.1089, 127.5322 +24507, 68.13285, 118.1504 +24508, 68.15041, 125.8468 +24509, 67.31379, 125.7108 +24510, 67.00484, 120.302 +24511, 67.77523, 136.9514 +24512, 67.94501, 124.8842 +24513, 69.49863, 107.795 +24514, 69.69959, 138.8638 +24515, 69.73603, 125.7504 +24516, 67.035, 110.6978 +24517, 68.55387, 106.0953 +24518, 67.66663, 118.1357 +24519, 68.19234, 130.5155 +24520, 67.83603, 125.6357 +24521, 65.6042, 121.2924 +24522, 70.79237, 135.705 +24523, 65.90734, 130.6877 +24524, 67.40279, 133.5585 +24525, 69.0652, 126.5715 +24526, 67.07127, 125.1982 +24527, 67.34987, 120.7703 +24528, 69.87618, 136.4152 +24529, 68.61786, 120.8313 +24530, 67.86452, 123.3904 +24531, 67.18841, 118.1254 +24532, 67.91023, 128.8423 +24533, 67.88438, 119.5715 +24534, 68.44835, 110.7671 +24535, 68.91398, 133.9166 +24536, 66.93704, 134.2708 +24537, 67.98509, 136.7816 +24538, 68.2376, 118.9982 +24539, 67.13801, 110.5575 +24540, 69.36053, 135.8541 +24541, 70.23741, 119.0039 +24542, 69.67473, 128.7848 +24543, 67.02658, 119.5814 +24544, 67.08012, 109.6164 +24545, 66.45348, 122.2987 +24546, 67.14627, 144.1873 +24547, 68.5299, 124.2064 +24548, 68.18035, 131.4399 +24549, 69.18019, 129.5663 +24550, 68.15579, 109.4756 +24551, 68.08451, 125.4961 +24552, 69.12967, 117.7697 +24553, 65.66134, 108.8434 +24554, 66.8266, 137.9539 +24555, 67.976, 125.9379 +24556, 68.6367, 126.662 +24557, 68.20125, 119.4097 +24558, 66.30752, 108.9388 +24559, 68.67523, 135.9253 +24560, 70.75177, 133.3227 +24561, 69.90591, 116.5433 +24562, 67.49121, 127.443 +24563, 69.43309, 126.7096 +24564, 66.64931, 119.9884 +24565, 67.25339, 122.7744 +24566, 70.0799, 116.5472 +24567, 67.30768, 124.8544 +24568, 68.90363, 139.9568 +24569, 67.79094, 134.4678 +24570, 70.02139, 141.1502 +24571, 65.08493, 113.6042 +24572, 68.00621, 143.7361 +24573, 72.3989, 144.9316 +24574, 67.83748, 132.585 +24575, 65.7028, 105.2162 +24576, 70.01957, 140.611 +24577, 67.87733, 116.6834 +24578, 70.66031, 122.3103 +24579, 69.84654, 131.7426 +24580, 67.08101, 123.8231 +24581, 68.19996, 120.8464 +24582, 66.47189, 117.481 +24583, 67.35479, 120.6077 +24584, 68.02985, 124.8289 +24585, 64.52777, 117.4798 +24586, 64.72981, 104.3111 +24587, 66.31479, 118.3695 +24588, 69.28443, 129.8202 +24589, 68.38512, 139.6485 +24590, 68.48504, 121.7782 +24591, 69.8409, 123.0627 +24592, 69.00164, 114.0904 +24593, 67.46717, 156.2682 +24594, 68.50704, 132.7862 +24595, 67.54149, 128.4227 +24596, 69.81014, 123.0582 +24597, 70.30911, 139.2419 +24598, 69.1204, 140.173 +24599, 71.55865, 136.6 +24600, 67.95604, 117.8046 +24601, 67.67595, 123.2158 +24602, 67.08059, 106.8189 +24603, 67.36378, 126.5004 +24604, 70.55218, 126.8437 +24605, 68.21612, 119.5574 +24606, 68.7151, 125.9951 +24607, 66.02245, 124.6736 +24608, 68.03719, 132.4732 +24609, 70.51604, 118.7315 +24610, 70.10402, 144.5009 +24611, 66.56804, 82.38298 +24612, 65.94065, 108.8379 +24613, 66.38829, 127.2815 +24614, 67.30654, 136.3496 +24615, 66.90193, 127.6108 +24616, 67.13761, 137.002 +24617, 68.93483, 143.9311 +24618, 67.95125, 118.8796 +24619, 72.47908, 148.1097 +24620, 65.52562, 123.3728 +24621, 69.32351, 146.246 +24622, 65.6099, 100.6414 +24623, 68.6201, 126.8121 +24624, 71.50024, 127.348 +24625, 66.67496, 115.2416 +24626, 66.73827, 129.1676 +24627, 67.26376, 128.3665 +24628, 69.70493, 139.7124 +24629, 69.81408, 111.8786 +24630, 69.24356, 155.8277 +24631, 63.65376, 110.0774 +24632, 67.32789, 137.1865 +24633, 68.6961, 132.4999 +24634, 66.62465, 120.2693 +24635, 69.65054, 142.7088 +24636, 69.0893, 137.7905 +24637, 66.75728, 110.8487 +24638, 66.06512, 106.9734 +24639, 66.00171, 115.4981 +24640, 68.70707, 101.3046 +24641, 69.29616, 136.4906 +24642, 68.68899, 138.3325 +24643, 69.36066, 141.9455 +24644, 71.21016, 133.633 +24645, 70.61617, 152.795 +24646, 66.60166, 131.846 +24647, 63.46025, 109.3417 +24648, 66.80019, 120.0755 +24649, 69.89469, 123.1536 +24650, 66.03755, 134.4459 +24651, 69.79279, 131.8303 +24652, 67.67011, 119.6221 +24653, 68.61358, 127.661 +24654, 67.29594, 119.9302 +24655, 68.06416, 126.1776 +24656, 67.08852, 133.3623 +24657, 67.22083, 133.1829 +24658, 68.52246, 121.9621 +24659, 69.21039, 126.6402 +24660, 68.11211, 125.7575 +24661, 69.80387, 128.2476 +24662, 64.30007, 108.2215 +24663, 67.06097, 135.8275 +24664, 65.65425, 108.0972 +24665, 71.03311, 137.8075 +24666, 67.66624, 121.9512 +24667, 65.33739, 121.2757 +24668, 69.54907, 124.4711 +24669, 67.45198, 109.1739 +24670, 67.84408, 110.1037 +24671, 69.48408, 122.6883 +24672, 66.19564, 122.6215 +24673, 68.96582, 125.7875 +24674, 68.91695, 122.4138 +24675, 67.15888, 115.731 +24676, 67.34512, 126.434 +24677, 68.00353, 131.0691 +24678, 68.05897, 115.6045 +24679, 67.12385, 130.4915 +24680, 68.24874, 123.1214 +24681, 70.06522, 132.9338 +24682, 67.50053, 119.1866 +24683, 69.12516, 131.2341 +24684, 69.0494, 137.1193 +24685, 67.66576, 120.0164 +24686, 69.54628, 124.9586 +24687, 68.28689, 135.0333 +24688, 69.39337, 112.8113 +24689, 67.30725, 120.8673 +24690, 68.34316, 139.0949 +24691, 70.90294, 143.8781 +24692, 64.06894, 99.60932 +24693, 67.2224, 121.3802 +24694, 68.69563, 137.2314 +24695, 66.13861, 120.2833 +24696, 69.54627, 137.3543 +24697, 66.14098, 125.3429 +24698, 70.63782, 151.2378 +24699, 70.03612, 125.3728 +24700, 67.57137, 122.2741 +24701, 66.91088, 107.3063 +24702, 66.91607, 120.8614 +24703, 68.68646, 137.1089 +24704, 66.02934, 132.9201 +24705, 67.42776, 113.7439 +24706, 69.3031, 134.3583 +24707, 69.24989, 121.6875 +24708, 68.89261, 133.0703 +24709, 68.86091, 126.9811 +24710, 71.90873, 134.0201 +24711, 68.26643, 129.7587 +24712, 66.59322, 113.153 +24713, 66.0497, 118.9106 +24714, 68.50987, 127.3332 +24715, 66.95287, 137.0653 +24716, 71.03063, 146.9723 +24717, 63.58121, 115.9351 +24718, 63.76497, 105.0288 +24719, 69.72296, 150.2475 +24720, 65.84023, 117.7307 +24721, 70.61722, 131.0053 +24722, 66.82089, 128.8345 +24723, 69.07869, 145.6238 +24724, 68.57406, 137.2053 +24725, 71.25702, 145.0337 +24726, 67.41157, 119.5434 +24727, 68.96896, 128.9336 +24728, 70.51128, 104.2914 +24729, 66.62109, 126.2567 +24730, 68.26107, 135.6492 +24731, 69.25005, 133.5514 +24732, 70.66498, 138.3137 +24733, 67.44799, 131.5456 +24734, 70.61052, 142.5544 +24735, 69.05707, 136.4888 +24736, 69.5556, 127.1593 +24737, 65.79335, 119.5829 +24738, 68.90813, 119.1438 +24739, 65.86615, 129.2224 +24740, 67.75381, 136.0158 +24741, 66.97192, 133.622 +24742, 67.12818, 138.6191 +24743, 68.03631, 112.7006 +24744, 69.2586, 132.689 +24745, 64.37881, 116.5423 +24746, 69.10476, 128.0676 +24747, 70.68086, 141.9627 +24748, 69.89281, 137.2342 +24749, 63.33113, 95.95417 +24750, 69.87096, 149.8839 +24751, 70.82192, 159.6344 +24752, 66.07971, 122.306 +24753, 71.10476, 114.7871 +24754, 68.65665, 117.2339 +24755, 65.5231, 123.7407 +24756, 69.2472, 119.0934 +24757, 70.19913, 124.0875 +24758, 68.23477, 115.1977 +24759, 70.12196, 127.7892 +24760, 66.798, 131.6398 +24761, 68.57737, 136.7561 +24762, 70.78151, 150.7636 +24763, 68.655, 134.1977 +24764, 70.04789, 116.0917 +24765, 67.3824, 131.8669 +24766, 69.704, 132.2823 +24767, 65.43275, 111.7034 +24768, 67.87092, 135.3133 +24769, 69.639, 122.774 +24770, 69.50107, 137.5292 +24771, 70.5769, 150.9049 +24772, 67.32704, 130.0925 +24773, 69.03615, 122.4746 +24774, 70.38448, 150.0339 +24775, 66.86316, 135.1726 +24776, 69.96058, 124.1244 +24777, 66.77948, 115.1505 +24778, 67.50335, 99.40058 +24779, 68.56426, 132.2101 +24780, 70.76528, 130.1221 +24781, 68.32253, 140.2104 +24782, 63.28029, 116.0598 +24783, 68.40535, 127.717 +24784, 70.47769, 132.7392 +24785, 70.92832, 133.3631 +24786, 68.42345, 121.5013 +24787, 68.17552, 113.1516 +24788, 71.41075, 126.4088 +24789, 70.02405, 138.9673 +24790, 70.06857, 132.7965 +24791, 67.87559, 131.4173 +24792, 68.09801, 132.7242 +24793, 67.93416, 125.6174 +24794, 70.56894, 127.3602 +24795, 64.3262, 114.3648 +24796, 67.77195, 114.3845 +24797, 67.75367, 113.554 +24798, 63.71439, 122.1264 +24799, 69.09925, 120.2482 +24800, 69.85179, 130.2025 +24801, 69.44092, 144.8549 +24802, 74.53177, 148.9104 +24803, 66.33132, 119.6675 +24804, 68.81086, 129.9323 +24805, 69.2946, 139.9604 +24806, 71.14495, 131.3502 +24807, 68.97051, 147.5332 +24808, 68.59823, 120.6693 +24809, 69.32375, 132.5228 +24810, 67.18403, 133.9888 +24811, 63.95584, 101.1775 +24812, 67.30139, 140.5981 +24813, 68.32525, 120.9681 +24814, 66.36458, 116.3494 +24815, 67.05441, 115.7106 +24816, 66.72856, 125.3558 +24817, 69.17136, 127.4447 +24818, 66.72634, 129.8871 +24819, 67.53447, 126.6146 +24820, 70.64693, 125.0381 +24821, 68.94919, 134.1113 +24822, 67.44368, 123.2024 +24823, 68.36479, 133.7593 +24824, 66.0173, 126.6746 +24825, 66.34051, 133.865 +24826, 69.11356, 140.5328 +24827, 66.78433, 146.9803 +24828, 64.69758, 116.5596 +24829, 67.88323, 132.9397 +24830, 70.79391, 140.861 +24831, 67.33031, 128.9386 +24832, 67.47175, 143.136 +24833, 71.1465, 131.7157 +24834, 71.09999, 132.7978 +24835, 67.31941, 117.9554 +24836, 65.17339, 94.40946 +24837, 70.79803, 141.7186 +24838, 70.54927, 150.3874 +24839, 68.88799, 114.2215 +24840, 65.19756, 127.3357 +24841, 67.13424, 126.6348 +24842, 70.79421, 134.6936 +24843, 66.08314, 116.8418 +24844, 67.55002, 122.1483 +24845, 67.74689, 132.8739 +24846, 70.05674, 146.0524 +24847, 69.39883, 144.6262 +24848, 69.51891, 120.1586 +24849, 67.9384, 125.9966 +24850, 63.84585, 135.1763 +24851, 68.53891, 134.0518 +24852, 65.58522, 127.3106 +24853, 66.56404, 97.80735 +24854, 67.21341, 137.2553 +24855, 67.11996, 105.438 +24856, 69.32371, 126.5148 +24857, 67.61647, 118.4966 +24858, 69.57478, 128.6012 +24859, 67.84663, 123.7062 +24860, 67.23558, 122.2566 +24861, 69.88379, 130.9158 +24862, 68.99994, 121.1935 +24863, 68.60312, 123.1076 +24864, 68.77791, 125.3572 +24865, 70.55859, 131.2843 +24866, 67.51836, 117.6823 +24867, 67.56651, 113.9729 +24868, 70.44326, 127.4526 +24869, 63.23624, 97.99816 +24870, 66.40576, 128.5103 +24871, 68.15859, 124.2586 +24872, 64.07289, 123.1365 +24873, 68.55598, 122.4432 +24874, 68.43131, 133.9318 +24875, 65.87921, 104.357 +24876, 66.68998, 128.4557 +24877, 65.95774, 127.8589 +24878, 70.30346, 137.8967 +24879, 69.37067, 120.4668 +24880, 67.55136, 133.2016 +24881, 64.66626, 117.3698 +24882, 66.40245, 132.6795 +24883, 70.0332, 134.9364 +24884, 73.06241, 141.5054 +24885, 67.73969, 107.6256 +24886, 69.27968, 139.7764 +24887, 64.56023, 114.473 +24888, 65.17345, 108.0286 +24889, 64.743, 106.8072 +24890, 71.01048, 161.8532 +24891, 69.12531, 149.3248 +24892, 68.90616, 144.6759 +24893, 69.68608, 134.7518 +24894, 70.89186, 139.6818 +24895, 66.75426, 130.7951 +24896, 66.84764, 112.43 +24897, 66.61327, 142.2755 +24898, 66.99191, 142.8088 +24899, 66.95526, 127.3362 +24900, 66.7864, 123.7754 +24901, 65.2558, 116.3788 +24902, 69.03557, 118.6868 +24903, 66.66842, 116.0167 +24904, 68.05827, 125.0539 +24905, 69.48675, 135.636 +24906, 69.11476, 132.8803 +24907, 69.57141, 126.5902 +24908, 68.45513, 119.3317 +24909, 67.61, 111.8791 +24910, 66.36029, 115.9904 +24911, 70.97938, 126.1772 +24912, 66.14233, 133.6664 +24913, 66.30402, 118.3665 +24914, 68.26234, 139.7222 +24915, 67.85823, 147.5064 +24916, 65.5061, 121.6958 +24917, 68.70761, 121.3583 +24918, 71.44954, 134.5787 +24919, 66.66413, 118.4386 +24920, 66.54027, 130.0576 +24921, 67.98947, 116.3439 +24922, 72.54953, 134.5143 +24923, 68.89705, 134.2033 +24924, 66.37489, 123.3152 +24925, 69.7564, 128.2928 +24926, 66.44678, 129.8237 +24927, 71.69485, 154.4811 +24928, 66.08091, 118.3239 +24929, 65.3417, 119.2852 +24930, 69.04974, 130.828 +24931, 65.11765, 99.42378 +24932, 69.44092, 141.7658 +24933, 66.63354, 123.5755 +24934, 69.01315, 136.6985 +24935, 67.57383, 135.223 +24936, 67.40523, 132.959 +24937, 67.01858, 122.8513 +24938, 65.90423, 115.7491 +24939, 70.35191, 118.6196 +24940, 72.35889, 143.9547 +24941, 68.90635, 135.0866 +24942, 68.40219, 109.4203 +24943, 68.51074, 139.2417 +24944, 68.94331, 128.0522 +24945, 67.83501, 125.6535 +24946, 67.62827, 122.4244 +24947, 67.79448, 121.2228 +24948, 69.17056, 154.7821 +24949, 67.9537, 126.585 +24950, 64.22634, 113.0611 +24951, 68.9995, 133.888 +24952, 68.21355, 131.1211 +24953, 67.77936, 122.7164 +24954, 67.83418, 138.3443 +24955, 66.69014, 119.1199 +24956, 67.54476, 104.238 +24957, 68.02864, 117.1596 +24958, 69.83059, 134.0241 +24959, 66.76934, 120.2857 +24960, 70.14626, 132.2209 +24961, 68.92465, 106.3021 +24962, 69.11543, 133.8436 +24963, 66.43732, 133.2403 +24964, 68.46555, 124.7422 +24965, 66.34781, 128.061 +24966, 66.7366, 124.5938 +24967, 66.08128, 130.3096 +24968, 66.55957, 115.0486 +24969, 69.08296, 127.4722 +24970, 63.61791, 115.7477 +24971, 65.37753, 126.6102 +24972, 67.4972, 122.9844 +24973, 68.70055, 123.2849 +24974, 71.32072, 125.5928 +24975, 65.57216, 123.7128 +24976, 66.19147, 123.2446 +24977, 70.06322, 115.418 +24978, 67.24989, 108.7178 +24979, 69.624, 141.5823 +24980, 66.7896, 120.8863 +24981, 69.79922, 154.4399 +24982, 66.30104, 107.3901 +24983, 68.36249, 118.7207 +24984, 63.77967, 111.4911 +24985, 67.58699, 127.7214 +24986, 69.71587, 133.9126 +24987, 68.81291, 120.8176 +24988, 68.86794, 142.8494 +24989, 66.10137, 103.381 +24990, 70.11839, 141.237 +24991, 69.97767, 125.3672 +24992, 71.91656, 128.284 +24993, 70.96218, 146.1936 +24994, 66.19462, 118.7974 +24995, 67.21126, 127.6603 +24996, 69.50215, 118.0312 +24997, 64.54826, 120.1932 +24998, 64.69855, 118.2655 +24999, 67.52918, 132.2682 +25000, 68.87761, 124.8742 diff --git a/demo/issues-cjs/303.js b/demo/issues-cjs/303.js new file mode 100644 index 000000000..9396d92b1 --- /dev/null +++ b/demo/issues-cjs/303.js @@ -0,0 +1,13 @@ + +const {parse} = require('csv-parse'); +const fs = require('fs'); + +// fs.createReadStream('./303.csv').pipe(parse()).on('data', data => { +// console.log(data); +// }); +fs.createReadStream('./303.csv').pipe(parse()) +.on('readable', function(){ + let record;while ((record = this.read()) !== null) { + // console.log(record); + } +}); diff --git a/demo/issues-cjs/package.json b/demo/issues-cjs/package.json new file mode 100644 index 000000000..ad65865ba --- /dev/null +++ b/demo/issues-cjs/package.json @@ -0,0 +1,26 @@ +{ + "name": "csv_issues_cjs", + "version": "0.0.0", + "main": "index.js", + "license": "MIT", + "private": true, + "devDependencies": { + "coffeescript": "^2.6.1", + "mocha": "^9.1.3", + "should": "^13.2.3" + }, + "mocha": { + "inline-diffs": true, + "loader": "./test/loaders/all.mjs", + "recursive": true, + "reporter": "spec", + "require": [ + "should" + ], + "throw-deprecation": true, + "timeout": 40000 + }, + "scripts": { + "test": "mocha 'test/**/*.coffee'" + } +} diff --git a/demo/issues/package.json b/demo/issues/package.json index 8e55ce893..4e454d7ed 100644 --- a/demo/issues/package.json +++ b/demo/issues/package.json @@ -1,5 +1,5 @@ { - "name": "csv_demo_cjs", + "name": "csv_issues_esm", "version": "0.0.0", "main": "index.js", "license": "MIT", diff --git a/packages/csv-generate/dist/cjs/index.cjs b/packages/csv-generate/dist/cjs/index.cjs index 50f66b8ff..c3090e110 100644 --- a/packages/csv-generate/dist/cjs/index.cjs +++ b/packages/csv-generate/dist/cjs/index.cjs @@ -2,5043 +2,13 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); +var stream = require('stream'); +var util = require('util'); -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer$1; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer$1(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNullOrUndefined(arg) { - return arg == null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isSymbol(arg) { - return typeof arg === 'symbol'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function isPrimitive(arg) { - return arg === null || - typeof arg === 'boolean' || - typeof arg === 'number' || - typeof arg === 'string' || - typeof arg === 'symbol' || // ES6 symbol - typeof arg === 'undefined'; -} - -function isBuffer(maybeBuf) { - return isBuffer$1(maybeBuf); -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - - -function pad(n) { - return n < 10 ? '0' + n.toString(10) : n.toString(10); -} - - -var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', - 'Oct', 'Nov', 'Dec']; - -// 26 Feb 16:19:34 -function timestamp() { - var d = new Date(); - var time = [pad(d.getHours()), - pad(d.getMinutes()), - pad(d.getSeconds())].join(':'); - return [d.getDate(), months[d.getMonth()], time].join(' '); -} - - -// log is just a thin wrapper to console.log that prepends a timestamp -function log() { - console.log('%s - %s', timestamp(), format.apply(null, arguments)); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -var util = { - inherits: inherits$1, - _extend: _extend, - log: log, - isBuffer: isBuffer, - isPrimitive: isPrimitive, - isFunction: isFunction, - isError: isError, - isDate: isDate, - isObject: isObject, - isRegExp: isRegExp, - isUndefined: isUndefined, - isSymbol: isSymbol, - isString: isString, - isNumber: isNumber, - isNullOrUndefined: isNullOrUndefined, - isNull: isNull, - isBoolean: isBoolean, - isArray: isArray, - inspect: inspect, - deprecate: deprecate, - format: format, - debuglog: debuglog -}; - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer$1(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream); +var util__default = /*#__PURE__*/_interopDefaultLegacy(util); const Generator = function(options = {}){ // Convert Stream Readable options if underscored @@ -5049,7 +19,7 @@ const Generator = function(options = {}){ options.objectMode = options.object_mode; } // Call parent constructor - Stream.Readable.call(this, options); + stream__default["default"].Readable.call(this, options); // Clone and camelize options this.options = {}; for(const k in options){ @@ -5101,7 +71,7 @@ const Generator = function(options = {}){ } return this; }; -util.inherits(Generator, Stream.Readable); +util__default["default"].inherits(Generator, stream__default["default"].Readable); // Generate a random number between 0 and 1 with 2 decimals. The function is idempotent if it detect the "seed" option. Generator.prototype.random = function(){ diff --git a/packages/csv-generate/dist/cjs/sync.cjs b/packages/csv-generate/dist/cjs/sync.cjs index ef92c1ee3..954822e35 100644 --- a/packages/csv-generate/dist/cjs/sync.cjs +++ b/packages/csv-generate/dist/cjs/sync.cjs @@ -2,5043 +2,13 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); +var stream = require('stream'); +var util = require('util'); -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer$1; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer$1(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNullOrUndefined(arg) { - return arg == null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isSymbol(arg) { - return typeof arg === 'symbol'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function isPrimitive(arg) { - return arg === null || - typeof arg === 'boolean' || - typeof arg === 'number' || - typeof arg === 'string' || - typeof arg === 'symbol' || // ES6 symbol - typeof arg === 'undefined'; -} - -function isBuffer(maybeBuf) { - return isBuffer$1(maybeBuf); -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - - -function pad(n) { - return n < 10 ? '0' + n.toString(10) : n.toString(10); -} - - -var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', - 'Oct', 'Nov', 'Dec']; - -// 26 Feb 16:19:34 -function timestamp() { - var d = new Date(); - var time = [pad(d.getHours()), - pad(d.getMinutes()), - pad(d.getSeconds())].join(':'); - return [d.getDate(), months[d.getMonth()], time].join(' '); -} - - -// log is just a thin wrapper to console.log that prepends a timestamp -function log() { - console.log('%s - %s', timestamp(), format.apply(null, arguments)); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -var util = { - inherits: inherits$1, - _extend: _extend, - log: log, - isBuffer: isBuffer, - isPrimitive: isPrimitive, - isFunction: isFunction, - isError: isError, - isDate: isDate, - isObject: isObject, - isRegExp: isRegExp, - isUndefined: isUndefined, - isSymbol: isSymbol, - isString: isString, - isNumber: isNumber, - isNullOrUndefined: isNullOrUndefined, - isNull: isNull, - isBoolean: isBoolean, - isArray: isArray, - inspect: inspect, - deprecate: deprecate, - format: format, - debuglog: debuglog -}; - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer$1(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream); +var util__default = /*#__PURE__*/_interopDefaultLegacy(util); const Generator = function(options = {}){ // Convert Stream Readable options if underscored @@ -5049,7 +19,7 @@ const Generator = function(options = {}){ options.objectMode = options.object_mode; } // Call parent constructor - Stream.Readable.call(this, options); + stream__default["default"].Readable.call(this, options); // Clone and camelize options this.options = {}; for(const k in options){ @@ -5101,7 +71,7 @@ const Generator = function(options = {}){ } return this; }; -util.inherits(Generator, Stream.Readable); +util__default["default"].inherits(Generator, stream__default["default"].Readable); // Generate a random number between 0 and 1 with 2 decimals. The function is idempotent if it detect the "seed" option. Generator.prototype.random = function(){ diff --git a/packages/csv-generate/rollup.config.js b/packages/csv-generate/rollup.config.js index bab683a12..6177f9031 100644 --- a/packages/csv-generate/rollup.config.js +++ b/packages/csv-generate/rollup.config.js @@ -14,10 +14,6 @@ export default [{ }, input: 'lib/index.js', output: [ - { - file: `dist/cjs/index.cjs`, - format: 'cjs' - }, { file: `dist/esm/index.js`, format: 'esm' @@ -36,6 +32,17 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/index.js', + output: [ + { + file: `dist/cjs/index.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }, { onwarn: function(warning, rollupWarn) { if (warning.code === 'CIRCULAR_DEPENDENCY') return; @@ -43,10 +50,6 @@ export default [{ }, input: 'lib/sync.js', output: [ - { - file: `dist/cjs/sync.cjs`, - format: 'cjs' - }, { file: `dist/esm/sync.js`, format: 'esm' @@ -65,4 +68,15 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/sync.js', + output: [ + { + file: `dist/cjs/sync.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }]; diff --git a/packages/csv-parse/dist/cjs/index.cjs b/packages/csv-parse/dist/cjs/index.cjs index da09aeee8..871e1aac6 100644 --- a/packages/csv-parse/dist/cjs/index.cjs +++ b/packages/csv-parse/dist/cjs/index.cjs @@ -2,4973 +2,7 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); - -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject$1(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject$1(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject$1(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject$1(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject$1(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject$1(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream = require('stream'); class ResizeableBuffer{ constructor(size=100){ @@ -4977,7 +11,7 @@ class ResizeableBuffer{ this.buf = Buffer.allocUnsafe(size); } prepend(val){ - if(isBuffer(val)){ + if(Buffer.isBuffer(val)){ const length = this.length + val.length; if(length >= this.size){ this.resize(); @@ -5064,7 +98,7 @@ class CsvError extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -5112,7 +146,7 @@ const normalizeColumnsArray = function(columns){ return normalizedColumns; }; -class Parser extends Transform { +class Parser extends stream.Transform { constructor(opts = {}){ super({...{readableObjectMode: true}, ...opts, encoding: null}); this.__originalOptions = opts; @@ -5215,7 +249,7 @@ class Parser extends Transform { if(typeof options.comment === 'string'){ options.comment = Buffer.from(options.comment, options.encoding); } - if(!isBuffer(options.comment)){ + if(!Buffer.isBuffer(options.comment)){ throw new CsvError('CSV_INVALID_OPTION_COMMENT', [ 'Invalid option comment:', 'comment must be a buffer or a string,', @@ -5240,7 +274,7 @@ class Parser extends Transform { if(typeof delimiter === 'string'){ delimiter = Buffer.from(delimiter, options.encoding); } - if(!isBuffer(delimiter) || delimiter.length === 0){ + if(!Buffer.isBuffer(delimiter) || delimiter.length === 0){ throw new CsvError('CSV_INVALID_OPTION_DELIMITER', [ 'Invalid option delimiter:', 'delimiter must be a non empty string or buffer or array of string|buffer,', @@ -5258,7 +292,7 @@ class Parser extends Transform { options.escape = null; } if(options.escape !== null){ - if(!isBuffer(options.escape)){ + if(!Buffer.isBuffer(options.escape)){ throw new Error(`Invalid Option: escape must be a buffer, a string or a boolean, got ${JSON.stringify(options.escape)}`); } } @@ -5330,7 +364,7 @@ class Parser extends Transform { // Normalize option `objname` if(options.objname === undefined || options.objname === null || options.objname === false){ options.objname = undefined; - }else if(isBuffer(options.objname)){ + }else if(Buffer.isBuffer(options.objname)){ if(options.objname.length === 0){ throw new Error(`Invalid Option: objname must be a non empty buffer`); } @@ -5375,7 +409,7 @@ class Parser extends Transform { }else if(typeof options.quote === 'string'){ options.quote = Buffer.from(options.quote, options.encoding); } - if(!isBuffer(options.quote)){ + if(!Buffer.isBuffer(options.quote)){ throw new Error(`Invalid Option: quote must be a buffer or a string, got ${JSON.stringify(options.quote)}`); } } @@ -5388,7 +422,7 @@ class Parser extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined){ options.record_delimiter = []; - }else if(typeof options.record_delimiter === 'string' || isBuffer(options.record_delimiter)){ + }else if(typeof options.record_delimiter === 'string' || Buffer.isBuffer(options.record_delimiter)){ if(options.record_delimiter.length === 0){ throw new CsvError('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', @@ -5405,7 +439,7 @@ class Parser extends Transform { ], options); } options.record_delimiter = options.record_delimiter.map(function(rd, i){ - if(typeof rd !== 'string' && ! isBuffer(rd)){ + if(typeof rd !== 'string' && ! Buffer.isBuffer(rd)){ throw new CsvError('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', 'value must be a string, a buffer or array of string|buffer', @@ -5542,7 +576,7 @@ class Parser extends Transform { error: undefined, enabled: options.from_line === 1, escaping: false, - escapeIsQuote: isBuffer(options.escape) && isBuffer(options.quote) && Buffer.compare(options.escape, options.quote) === 0, + escapeIsQuote: Buffer.isBuffer(options.escape) && Buffer.isBuffer(options.quote) && Buffer.compare(options.escape, options.quote) === 0, // columns can be `false`, `true`, `Array` expectedRecordLength: Array.isArray(options.columns) ? options.columns.length : undefined, field: new ResizeableBuffer(20), @@ -6244,7 +1278,7 @@ const parse = function(){ for(const i in arguments){ const argument = arguments[i]; const type = typeof argument; - if(data === undefined && (typeof argument === 'string' || isBuffer(argument))){ + if(data === undefined && (typeof argument === 'string' || Buffer.isBuffer(argument))){ data = argument; }else if(options === undefined && isObject(argument)){ options = argument; diff --git a/packages/csv-parse/dist/cjs/sync.cjs b/packages/csv-parse/dist/cjs/sync.cjs index be5e1de90..29e5875f7 100644 --- a/packages/csv-parse/dist/cjs/sync.cjs +++ b/packages/csv-parse/dist/cjs/sync.cjs @@ -2,4973 +2,7 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); - -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject$1(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject$1(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject$1(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject$1(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject$1(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject$1(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream = require('stream'); class ResizeableBuffer{ constructor(size=100){ @@ -4977,7 +11,7 @@ class ResizeableBuffer{ this.buf = Buffer.allocUnsafe(size); } prepend(val){ - if(isBuffer(val)){ + if(Buffer.isBuffer(val)){ const length = this.length + val.length; if(length >= this.size){ this.resize(); @@ -5064,7 +98,7 @@ class CsvError extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -5112,7 +146,7 @@ const normalizeColumnsArray = function(columns){ return normalizedColumns; }; -class Parser extends Transform { +class Parser extends stream.Transform { constructor(opts = {}){ super({...{readableObjectMode: true}, ...opts, encoding: null}); this.__originalOptions = opts; @@ -5215,7 +249,7 @@ class Parser extends Transform { if(typeof options.comment === 'string'){ options.comment = Buffer.from(options.comment, options.encoding); } - if(!isBuffer(options.comment)){ + if(!Buffer.isBuffer(options.comment)){ throw new CsvError('CSV_INVALID_OPTION_COMMENT', [ 'Invalid option comment:', 'comment must be a buffer or a string,', @@ -5240,7 +274,7 @@ class Parser extends Transform { if(typeof delimiter === 'string'){ delimiter = Buffer.from(delimiter, options.encoding); } - if(!isBuffer(delimiter) || delimiter.length === 0){ + if(!Buffer.isBuffer(delimiter) || delimiter.length === 0){ throw new CsvError('CSV_INVALID_OPTION_DELIMITER', [ 'Invalid option delimiter:', 'delimiter must be a non empty string or buffer or array of string|buffer,', @@ -5258,7 +292,7 @@ class Parser extends Transform { options.escape = null; } if(options.escape !== null){ - if(!isBuffer(options.escape)){ + if(!Buffer.isBuffer(options.escape)){ throw new Error(`Invalid Option: escape must be a buffer, a string or a boolean, got ${JSON.stringify(options.escape)}`); } } @@ -5330,7 +364,7 @@ class Parser extends Transform { // Normalize option `objname` if(options.objname === undefined || options.objname === null || options.objname === false){ options.objname = undefined; - }else if(isBuffer(options.objname)){ + }else if(Buffer.isBuffer(options.objname)){ if(options.objname.length === 0){ throw new Error(`Invalid Option: objname must be a non empty buffer`); } @@ -5375,7 +409,7 @@ class Parser extends Transform { }else if(typeof options.quote === 'string'){ options.quote = Buffer.from(options.quote, options.encoding); } - if(!isBuffer(options.quote)){ + if(!Buffer.isBuffer(options.quote)){ throw new Error(`Invalid Option: quote must be a buffer or a string, got ${JSON.stringify(options.quote)}`); } } @@ -5388,7 +422,7 @@ class Parser extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined){ options.record_delimiter = []; - }else if(typeof options.record_delimiter === 'string' || isBuffer(options.record_delimiter)){ + }else if(typeof options.record_delimiter === 'string' || Buffer.isBuffer(options.record_delimiter)){ if(options.record_delimiter.length === 0){ throw new CsvError('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', @@ -5405,7 +439,7 @@ class Parser extends Transform { ], options); } options.record_delimiter = options.record_delimiter.map(function(rd, i){ - if(typeof rd !== 'string' && ! isBuffer(rd)){ + if(typeof rd !== 'string' && ! Buffer.isBuffer(rd)){ throw new CsvError('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', 'value must be a string, a buffer or array of string|buffer', @@ -5542,7 +576,7 @@ class Parser extends Transform { error: undefined, enabled: options.from_line === 1, escaping: false, - escapeIsQuote: isBuffer(options.escape) && isBuffer(options.quote) && Buffer.compare(options.escape, options.quote) === 0, + escapeIsQuote: Buffer.isBuffer(options.escape) && Buffer.isBuffer(options.quote) && Buffer.compare(options.escape, options.quote) === 0, // columns can be `false`, `true`, `Array` expectedRecordLength: Array.isArray(options.columns) ? options.columns.length : undefined, field: new ResizeableBuffer(20), diff --git a/packages/csv-parse/rollup.config.js b/packages/csv-parse/rollup.config.js index 14aa81c15..88884a159 100644 --- a/packages/csv-parse/rollup.config.js +++ b/packages/csv-parse/rollup.config.js @@ -14,10 +14,6 @@ export default [{ }, input: 'lib/index.js', output: [ - { - file: `dist/cjs/index.cjs`, - format: 'cjs' - }, { file: `dist/esm/index.js`, format: 'esm' @@ -36,6 +32,17 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/index.js', + output: [ + { + file: `dist/cjs/index.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }, { onwarn: function(warning, rollupWarn) { if (warning.code === 'CIRCULAR_DEPENDENCY') return; @@ -43,10 +50,6 @@ export default [{ }, input: 'lib/sync.js', output: [ - { - file: `dist/cjs/sync.cjs`, - format: 'cjs' - }, { file: `dist/esm/sync.js`, format: 'esm' @@ -65,4 +68,15 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/sync.js', + output: [ + { + file: `dist/cjs/sync.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }]; diff --git a/packages/csv-stringify/dist/cjs/index.cjs b/packages/csv-stringify/dist/cjs/index.cjs index c60153523..e5c618c7a 100644 --- a/packages/csv-stringify/dist/cjs/index.cjs +++ b/packages/csv-stringify/dist/cjs/index.cjs @@ -2,4973 +2,7 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); - -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject$1(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject$1(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject$1(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject$1(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject$1(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject$1(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream = require('stream'); const bom_utf8 = Buffer.from([239, 187, 191]); @@ -4983,7 +17,7 @@ class CsvError extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -5076,7 +110,7 @@ const get = function(object, path){ return (index && index === length) ? object : undefined; }; -class Stringifier extends Transform { +class Stringifier extends stream.Transform { constructor(opts = {}){ super({...{writableObjectMode: true}, ...opts}); const options = {}; @@ -5130,7 +164,7 @@ class Stringifier extends Transform { // Normalize option `delimiter` if(options.delimiter === undefined || options.delimiter === null){ options.delimiter = ','; - }else if(isBuffer(options.delimiter)){ + }else if(Buffer.isBuffer(options.delimiter)){ options.delimiter = options.delimiter.toString(); }else if(typeof options.delimiter !== 'string'){ return new CsvError('CSV_OPTION_DELIMITER_INVALID_TYPE', [ @@ -5145,7 +179,7 @@ class Stringifier extends Transform { options.quote = '"'; }else if(options.quote === false){ options.quote = ''; - }else if (isBuffer(options.quote)){ + }else if (Buffer.isBuffer(options.quote)){ options.quote = options.quote.toString(); }else if(typeof options.quote !== 'string'){ return new CsvError('CSV_OPTION_QUOTE_INVALID_TYPE', [ @@ -5187,7 +221,7 @@ class Stringifier extends Transform { // Normalize option `escape` if(options.escape === undefined || options.escape === null){ options.escape = '"'; - }else if(isBuffer(options.escape)){ + }else if(Buffer.isBuffer(options.escape)){ options.escape = options.escape.toString(); }else if(typeof options.escape !== 'string'){ return Error(`Invalid Option: escape must be a buffer or a string, got ${JSON.stringify(options.escape)}`); @@ -5242,7 +276,7 @@ class Stringifier extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined || options.record_delimiter === null){ options.record_delimiter = '\n'; - }else if(isBuffer(options.record_delimiter)){ + }else if(Buffer.isBuffer(options.record_delimiter)){ options.record_delimiter = options.record_delimiter.toString(); }else if(typeof options.record_delimiter !== 'string'){ return Error(`Invalid Option: record_delimiter must be a buffer or a string, got ${JSON.stringify(options.record_delimiter)}`); diff --git a/packages/csv-stringify/dist/cjs/sync.cjs b/packages/csv-stringify/dist/cjs/sync.cjs index fe0e0a538..3f5725f6b 100644 --- a/packages/csv-stringify/dist/cjs/sync.cjs +++ b/packages/csv-stringify/dist/cjs/sync.cjs @@ -2,4973 +2,8 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); - -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject$1(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject$1(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject$1(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject$1(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject$1(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject$1(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream = require('stream'); +var string_decoder = require('string_decoder'); const bom_utf8 = Buffer.from([239, 187, 191]); @@ -4983,7 +18,7 @@ class CsvError extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -5076,7 +111,7 @@ const get = function(object, path){ return (index && index === length) ? object : undefined; }; -class Stringifier extends Transform { +class Stringifier extends stream.Transform { constructor(opts = {}){ super({...{writableObjectMode: true}, ...opts}); const options = {}; @@ -5130,7 +165,7 @@ class Stringifier extends Transform { // Normalize option `delimiter` if(options.delimiter === undefined || options.delimiter === null){ options.delimiter = ','; - }else if(isBuffer(options.delimiter)){ + }else if(Buffer.isBuffer(options.delimiter)){ options.delimiter = options.delimiter.toString(); }else if(typeof options.delimiter !== 'string'){ return new CsvError('CSV_OPTION_DELIMITER_INVALID_TYPE', [ @@ -5145,7 +180,7 @@ class Stringifier extends Transform { options.quote = '"'; }else if(options.quote === false){ options.quote = ''; - }else if (isBuffer(options.quote)){ + }else if (Buffer.isBuffer(options.quote)){ options.quote = options.quote.toString(); }else if(typeof options.quote !== 'string'){ return new CsvError('CSV_OPTION_QUOTE_INVALID_TYPE', [ @@ -5187,7 +222,7 @@ class Stringifier extends Transform { // Normalize option `escape` if(options.escape === undefined || options.escape === null){ options.escape = '"'; - }else if(isBuffer(options.escape)){ + }else if(Buffer.isBuffer(options.escape)){ options.escape = options.escape.toString(); }else if(typeof options.escape !== 'string'){ return Error(`Invalid Option: escape must be a buffer or a string, got ${JSON.stringify(options.escape)}`); @@ -5242,7 +277,7 @@ class Stringifier extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined || options.record_delimiter === null){ options.record_delimiter = '\n'; - }else if(isBuffer(options.record_delimiter)){ + }else if(Buffer.isBuffer(options.record_delimiter)){ options.record_delimiter = options.record_delimiter.toString(); }else if(typeof options.record_delimiter !== 'string'){ return Error(`Invalid Option: record_delimiter must be a buffer or a string, got ${JSON.stringify(options.record_delimiter)}`); @@ -5508,8 +543,8 @@ class Stringifier extends Transform { const stringify = function(records, options={}){ const data = []; - if(isBuffer(records)){ - const decoder = new StringDecoder(); + if(Buffer.isBuffer(records)){ + const decoder = new string_decoder.StringDecoder(); records = decoder.write(records); } function onData(record){ diff --git a/packages/csv-stringify/rollup.config.js b/packages/csv-stringify/rollup.config.js index fd4d0b688..ba5136784 100644 --- a/packages/csv-stringify/rollup.config.js +++ b/packages/csv-stringify/rollup.config.js @@ -14,10 +14,6 @@ export default [{ }, input: 'lib/index.js', output: [ - { - file: `dist/cjs/index.cjs`, - format: 'cjs' - }, { file: `dist/esm/index.js`, format: 'esm' @@ -36,6 +32,17 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/index.js', + output: [ + { + file: `dist/cjs/index.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }, { onwarn: function(warning, rollupWarn) { if (warning.code === 'CIRCULAR_DEPENDENCY') return; @@ -43,10 +50,6 @@ export default [{ }, input: 'lib/sync.js', output: [ - { - file: `dist/cjs/sync.cjs`, - format: 'cjs' - }, { file: `dist/esm/sync.js`, format: 'esm' @@ -65,4 +68,15 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/sync.js', + output: [ + { + file: `dist/cjs/sync.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }]; diff --git a/packages/csv/dist/cjs/index.cjs b/packages/csv/dist/cjs/index.cjs index 465aa1293..b6b0aa3ea 100644 --- a/packages/csv/dist/cjs/index.cjs +++ b/packages/csv/dist/cjs/index.cjs @@ -2,5043 +2,13 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); +var stream = require('stream'); +var util = require('util'); -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer$1; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer$1(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject$2(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNullOrUndefined(arg) { - return arg == null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isSymbol$1(arg) { - return typeof arg === 'symbol'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject$2(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject$2(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject$2(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject$2(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function isPrimitive(arg) { - return arg === null || - typeof arg === 'boolean' || - typeof arg === 'number' || - typeof arg === 'string' || - typeof arg === 'symbol' || // ES6 symbol - typeof arg === 'undefined'; -} - -function isBuffer(maybeBuf) { - return isBuffer$1(maybeBuf); -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - - -function pad(n) { - return n < 10 ? '0' + n.toString(10) : n.toString(10); -} - - -var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', - 'Oct', 'Nov', 'Dec']; - -// 26 Feb 16:19:34 -function timestamp() { - var d = new Date(); - var time = [pad(d.getHours()), - pad(d.getMinutes()), - pad(d.getSeconds())].join(':'); - return [d.getDate(), months[d.getMonth()], time].join(' '); -} - - -// log is just a thin wrapper to console.log that prepends a timestamp -function log() { - console.log('%s - %s', timestamp(), format.apply(null, arguments)); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject$2(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -var util = { - inherits: inherits$1, - _extend: _extend, - log: log, - isBuffer: isBuffer, - isPrimitive: isPrimitive, - isFunction: isFunction, - isError: isError, - isDate: isDate, - isObject: isObject$2, - isRegExp: isRegExp, - isUndefined: isUndefined, - isSymbol: isSymbol$1, - isString: isString, - isNumber: isNumber, - isNullOrUndefined: isNullOrUndefined, - isNull: isNull, - isBoolean: isBoolean, - isArray: isArray, - inspect: inspect, - deprecate: deprecate, - format: format, - debuglog: debuglog -}; - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer$1(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream); +var util__default = /*#__PURE__*/_interopDefaultLegacy(util); const Generator = function(options = {}){ // Convert Stream Readable options if underscored @@ -5049,7 +19,7 @@ const Generator = function(options = {}){ options.objectMode = options.object_mode; } // Call parent constructor - Stream.Readable.call(this, options); + stream__default["default"].Readable.call(this, options); // Clone and camelize options this.options = {}; for(const k in options){ @@ -5101,7 +71,7 @@ const Generator = function(options = {}){ } return this; }; -util.inherits(Generator, Stream.Readable); +util__default["default"].inherits(Generator, stream__default["default"].Readable); // Generate a random number between 0 and 1 with 2 decimals. The function is idempotent if it detect the "seed" option. Generator.prototype.random = function(){ @@ -5263,10 +233,10 @@ class ResizeableBuffer{ constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ - if(isBuffer$1(val)){ + if(Buffer.isBuffer(val)){ const length = this.length + val.length; if(length >= this.size){ this.resize(); @@ -5275,7 +245,7 @@ class ResizeableBuffer{ } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5302,7 +272,7 @@ class ResizeableBuffer{ resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } @@ -5353,7 +323,7 @@ class CsvError$1 extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer$1(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -5401,7 +371,7 @@ const normalizeColumnsArray = function(columns){ return normalizedColumns; }; -class Parser extends Transform { +class Parser extends stream.Transform { constructor(opts = {}){ super({...{readableObjectMode: true}, ...opts, encoding: null}); this.__originalOptions = opts; @@ -5504,7 +474,7 @@ class Parser extends Transform { if(typeof options.comment === 'string'){ options.comment = Buffer.from(options.comment, options.encoding); } - if(!isBuffer$1(options.comment)){ + if(!Buffer.isBuffer(options.comment)){ throw new CsvError$1('CSV_INVALID_OPTION_COMMENT', [ 'Invalid option comment:', 'comment must be a buffer or a string,', @@ -5529,7 +499,7 @@ class Parser extends Transform { if(typeof delimiter === 'string'){ delimiter = Buffer.from(delimiter, options.encoding); } - if(!isBuffer$1(delimiter) || delimiter.length === 0){ + if(!Buffer.isBuffer(delimiter) || delimiter.length === 0){ throw new CsvError$1('CSV_INVALID_OPTION_DELIMITER', [ 'Invalid option delimiter:', 'delimiter must be a non empty string or buffer or array of string|buffer,', @@ -5547,7 +517,7 @@ class Parser extends Transform { options.escape = null; } if(options.escape !== null){ - if(!isBuffer$1(options.escape)){ + if(!Buffer.isBuffer(options.escape)){ throw new Error(`Invalid Option: escape must be a buffer, a string or a boolean, got ${JSON.stringify(options.escape)}`); } } @@ -5619,7 +589,7 @@ class Parser extends Transform { // Normalize option `objname` if(options.objname === undefined || options.objname === null || options.objname === false){ options.objname = undefined; - }else if(isBuffer$1(options.objname)){ + }else if(Buffer.isBuffer(options.objname)){ if(options.objname.length === 0){ throw new Error(`Invalid Option: objname must be a non empty buffer`); } @@ -5664,7 +634,7 @@ class Parser extends Transform { }else if(typeof options.quote === 'string'){ options.quote = Buffer.from(options.quote, options.encoding); } - if(!isBuffer$1(options.quote)){ + if(!Buffer.isBuffer(options.quote)){ throw new Error(`Invalid Option: quote must be a buffer or a string, got ${JSON.stringify(options.quote)}`); } } @@ -5677,7 +647,7 @@ class Parser extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined){ options.record_delimiter = []; - }else if(typeof options.record_delimiter === 'string' || isBuffer$1(options.record_delimiter)){ + }else if(typeof options.record_delimiter === 'string' || Buffer.isBuffer(options.record_delimiter)){ if(options.record_delimiter.length === 0){ throw new CsvError$1('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', @@ -5694,7 +664,7 @@ class Parser extends Transform { ], options); } options.record_delimiter = options.record_delimiter.map(function(rd, i){ - if(typeof rd !== 'string' && ! isBuffer$1(rd)){ + if(typeof rd !== 'string' && ! Buffer.isBuffer(rd)){ throw new CsvError$1('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', 'value must be a string, a buffer or array of string|buffer', @@ -5831,7 +801,7 @@ class Parser extends Transform { error: undefined, enabled: options.from_line === 1, escaping: false, - escapeIsQuote: isBuffer$1(options.escape) && isBuffer$1(options.quote) && Buffer.compare(options.escape, options.quote) === 0, + escapeIsQuote: Buffer.isBuffer(options.escape) && Buffer.isBuffer(options.quote) && Buffer.compare(options.escape, options.quote) === 0, // columns can be `false`, `true`, `Array` expectedRecordLength: Array.isArray(options.columns) ? options.columns.length : undefined, field: new ResizeableBuffer(20), @@ -6533,7 +1503,7 @@ const parse = function(){ for(const i in arguments){ const argument = arguments[i]; const type = typeof argument; - if(data === undefined && (typeof argument === 'string' || isBuffer$1(argument))){ + if(data === undefined && (typeof argument === 'string' || Buffer.isBuffer(argument))){ data = argument; }else if(options === undefined && isObject$1(argument)){ options = argument; @@ -6594,7 +1564,7 @@ const Transformer = function(options = {}, handler){ options.params = null; } this.handler = handler; - Stream.Transform.call(this, this.options); + stream__default["default"].Transform.call(this, this.options); this.state = { running: 0, started: 0, @@ -6603,7 +1573,7 @@ const Transformer = function(options = {}, handler){ return this; }; -util.inherits(Transformer, Stream.Transform); +util__default["default"].inherits(Transformer, stream__default["default"].Transform); Transformer.prototype._transform = function(chunk, encoding, cb){ this.state.started++; @@ -6739,7 +1709,7 @@ class CsvError extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer$1(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -6832,7 +1802,7 @@ const get = function(object, path){ return (index && index === length) ? object : undefined; }; -class Stringifier extends Transform { +class Stringifier extends stream.Transform { constructor(opts = {}){ super({...{writableObjectMode: true}, ...opts}); const options = {}; @@ -6886,7 +1856,7 @@ class Stringifier extends Transform { // Normalize option `delimiter` if(options.delimiter === undefined || options.delimiter === null){ options.delimiter = ','; - }else if(isBuffer$1(options.delimiter)){ + }else if(Buffer.isBuffer(options.delimiter)){ options.delimiter = options.delimiter.toString(); }else if(typeof options.delimiter !== 'string'){ return new CsvError('CSV_OPTION_DELIMITER_INVALID_TYPE', [ @@ -6901,7 +1871,7 @@ class Stringifier extends Transform { options.quote = '"'; }else if(options.quote === false){ options.quote = ''; - }else if (isBuffer$1(options.quote)){ + }else if (Buffer.isBuffer(options.quote)){ options.quote = options.quote.toString(); }else if(typeof options.quote !== 'string'){ return new CsvError('CSV_OPTION_QUOTE_INVALID_TYPE', [ @@ -6943,7 +1913,7 @@ class Stringifier extends Transform { // Normalize option `escape` if(options.escape === undefined || options.escape === null){ options.escape = '"'; - }else if(isBuffer$1(options.escape)){ + }else if(Buffer.isBuffer(options.escape)){ options.escape = options.escape.toString(); }else if(typeof options.escape !== 'string'){ return Error(`Invalid Option: escape must be a buffer or a string, got ${JSON.stringify(options.escape)}`); @@ -6998,7 +1968,7 @@ class Stringifier extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined || options.record_delimiter === null){ options.record_delimiter = '\n'; - }else if(isBuffer$1(options.record_delimiter)){ + }else if(Buffer.isBuffer(options.record_delimiter)){ options.record_delimiter = options.record_delimiter.toString(); }else if(typeof options.record_delimiter !== 'string'){ return Error(`Invalid Option: record_delimiter must be a buffer or a string, got ${JSON.stringify(options.record_delimiter)}`); diff --git a/packages/csv/dist/cjs/sync.cjs b/packages/csv/dist/cjs/sync.cjs index 12a77427f..e85a3f03f 100644 --- a/packages/csv/dist/cjs/sync.cjs +++ b/packages/csv/dist/cjs/sync.cjs @@ -2,5043 +2,14 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); +var stream = require('stream'); +var util = require('util'); +var string_decoder = require('string_decoder'); -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer$1; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer$1(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -var domain; - -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); - -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject$2(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNullOrUndefined(arg) { - return arg == null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isSymbol$1(arg) { - return typeof arg === 'symbol'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject$2(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject$2(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject$2(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject$2(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function isPrimitive(arg) { - return arg === null || - typeof arg === 'boolean' || - typeof arg === 'number' || - typeof arg === 'string' || - typeof arg === 'symbol' || // ES6 symbol - typeof arg === 'undefined'; -} - -function isBuffer(maybeBuf) { - return isBuffer$1(maybeBuf); -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - - -function pad(n) { - return n < 10 ? '0' + n.toString(10) : n.toString(10); -} - - -var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', - 'Oct', 'Nov', 'Dec']; - -// 26 Feb 16:19:34 -function timestamp() { - var d = new Date(); - var time = [pad(d.getHours()), - pad(d.getMinutes()), - pad(d.getSeconds())].join(':'); - return [d.getDate(), months[d.getMonth()], time].join(' '); -} - - -// log is just a thin wrapper to console.log that prepends a timestamp -function log() { - console.log('%s - %s', timestamp(), format.apply(null, arguments)); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject$2(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -var util = { - inherits: inherits$1, - _extend: _extend, - log: log, - isBuffer: isBuffer, - isPrimitive: isPrimitive, - isFunction: isFunction, - isError: isError, - isDate: isDate, - isObject: isObject$2, - isRegExp: isRegExp, - isUndefined: isUndefined, - isSymbol: isSymbol$1, - isString: isString, - isNumber: isNumber, - isNullOrUndefined: isNullOrUndefined, - isNull: isNull, - isBoolean: isBoolean, - isArray: isArray, - inspect: inspect, - deprecate: deprecate, - format: format, - debuglog: debuglog -}; - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer$1(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream); +var util__default = /*#__PURE__*/_interopDefaultLegacy(util); const Generator = function(options = {}){ // Convert Stream Readable options if underscored @@ -5049,7 +20,7 @@ const Generator = function(options = {}){ options.objectMode = options.object_mode; } // Call parent constructor - Stream.Readable.call(this, options); + stream__default["default"].Readable.call(this, options); // Clone and camelize options this.options = {}; for(const k in options){ @@ -5101,7 +72,7 @@ const Generator = function(options = {}){ } return this; }; -util.inherits(Generator, Stream.Readable); +util__default["default"].inherits(Generator, stream__default["default"].Readable); // Generate a random number between 0 and 1 with 2 decimals. The function is idempotent if it detect the "seed" option. Generator.prototype.random = function(){ @@ -5260,10 +231,10 @@ class ResizeableBuffer{ constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ - if(isBuffer$1(val)){ + if(Buffer.isBuffer(val)){ const length = this.length + val.length; if(length >= this.size){ this.resize(); @@ -5272,7 +243,7 @@ class ResizeableBuffer{ } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5299,7 +270,7 @@ class ResizeableBuffer{ resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } @@ -5350,7 +321,7 @@ class CsvError$1 extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer$1(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString(options.encoding) : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -5398,7 +369,7 @@ const normalizeColumnsArray = function(columns){ return normalizedColumns; }; -class Parser extends Transform { +class Parser extends stream.Transform { constructor(opts = {}){ super({...{readableObjectMode: true}, ...opts, encoding: null}); this.__originalOptions = opts; @@ -5501,7 +472,7 @@ class Parser extends Transform { if(typeof options.comment === 'string'){ options.comment = Buffer.from(options.comment, options.encoding); } - if(!isBuffer$1(options.comment)){ + if(!Buffer.isBuffer(options.comment)){ throw new CsvError$1('CSV_INVALID_OPTION_COMMENT', [ 'Invalid option comment:', 'comment must be a buffer or a string,', @@ -5526,7 +497,7 @@ class Parser extends Transform { if(typeof delimiter === 'string'){ delimiter = Buffer.from(delimiter, options.encoding); } - if(!isBuffer$1(delimiter) || delimiter.length === 0){ + if(!Buffer.isBuffer(delimiter) || delimiter.length === 0){ throw new CsvError$1('CSV_INVALID_OPTION_DELIMITER', [ 'Invalid option delimiter:', 'delimiter must be a non empty string or buffer or array of string|buffer,', @@ -5544,7 +515,7 @@ class Parser extends Transform { options.escape = null; } if(options.escape !== null){ - if(!isBuffer$1(options.escape)){ + if(!Buffer.isBuffer(options.escape)){ throw new Error(`Invalid Option: escape must be a buffer, a string or a boolean, got ${JSON.stringify(options.escape)}`); } } @@ -5616,7 +587,7 @@ class Parser extends Transform { // Normalize option `objname` if(options.objname === undefined || options.objname === null || options.objname === false){ options.objname = undefined; - }else if(isBuffer$1(options.objname)){ + }else if(Buffer.isBuffer(options.objname)){ if(options.objname.length === 0){ throw new Error(`Invalid Option: objname must be a non empty buffer`); } @@ -5661,7 +632,7 @@ class Parser extends Transform { }else if(typeof options.quote === 'string'){ options.quote = Buffer.from(options.quote, options.encoding); } - if(!isBuffer$1(options.quote)){ + if(!Buffer.isBuffer(options.quote)){ throw new Error(`Invalid Option: quote must be a buffer or a string, got ${JSON.stringify(options.quote)}`); } } @@ -5674,7 +645,7 @@ class Parser extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined){ options.record_delimiter = []; - }else if(typeof options.record_delimiter === 'string' || isBuffer$1(options.record_delimiter)){ + }else if(typeof options.record_delimiter === 'string' || Buffer.isBuffer(options.record_delimiter)){ if(options.record_delimiter.length === 0){ throw new CsvError$1('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', @@ -5691,7 +662,7 @@ class Parser extends Transform { ], options); } options.record_delimiter = options.record_delimiter.map(function(rd, i){ - if(typeof rd !== 'string' && ! isBuffer$1(rd)){ + if(typeof rd !== 'string' && ! Buffer.isBuffer(rd)){ throw new CsvError$1('CSV_INVALID_OPTION_RECORD_DELIMITER', [ 'Invalid option `record_delimiter`:', 'value must be a string, a buffer or array of string|buffer', @@ -5828,7 +799,7 @@ class Parser extends Transform { error: undefined, enabled: options.from_line === 1, escaping: false, - escapeIsQuote: isBuffer$1(options.escape) && isBuffer$1(options.quote) && Buffer.compare(options.escape, options.quote) === 0, + escapeIsQuote: Buffer.isBuffer(options.escape) && Buffer.isBuffer(options.quote) && Buffer.compare(options.escape, options.quote) === 0, // columns can be `false`, `true`, `Array` expectedRecordLength: Array.isArray(options.columns) ? options.columns.length : undefined, field: new ResizeableBuffer(20), @@ -6561,7 +1532,7 @@ class CsvError extends Error { for(const context of contexts){ for(const key in context){ const value = context[key]; - this[key] = isBuffer$1(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); + this[key] = Buffer.isBuffer(value) ? value.toString() : value == null ? value : JSON.parse(JSON.stringify(value)); } } } @@ -6654,7 +1625,7 @@ const get = function(object, path){ return (index && index === length) ? object : undefined; }; -class Stringifier extends Transform { +class Stringifier extends stream.Transform { constructor(opts = {}){ super({...{writableObjectMode: true}, ...opts}); const options = {}; @@ -6708,7 +1679,7 @@ class Stringifier extends Transform { // Normalize option `delimiter` if(options.delimiter === undefined || options.delimiter === null){ options.delimiter = ','; - }else if(isBuffer$1(options.delimiter)){ + }else if(Buffer.isBuffer(options.delimiter)){ options.delimiter = options.delimiter.toString(); }else if(typeof options.delimiter !== 'string'){ return new CsvError('CSV_OPTION_DELIMITER_INVALID_TYPE', [ @@ -6723,7 +1694,7 @@ class Stringifier extends Transform { options.quote = '"'; }else if(options.quote === false){ options.quote = ''; - }else if (isBuffer$1(options.quote)){ + }else if (Buffer.isBuffer(options.quote)){ options.quote = options.quote.toString(); }else if(typeof options.quote !== 'string'){ return new CsvError('CSV_OPTION_QUOTE_INVALID_TYPE', [ @@ -6765,7 +1736,7 @@ class Stringifier extends Transform { // Normalize option `escape` if(options.escape === undefined || options.escape === null){ options.escape = '"'; - }else if(isBuffer$1(options.escape)){ + }else if(Buffer.isBuffer(options.escape)){ options.escape = options.escape.toString(); }else if(typeof options.escape !== 'string'){ return Error(`Invalid Option: escape must be a buffer or a string, got ${JSON.stringify(options.escape)}`); @@ -6820,7 +1791,7 @@ class Stringifier extends Transform { // Normalize option `record_delimiter` if(options.record_delimiter === undefined || options.record_delimiter === null){ options.record_delimiter = '\n'; - }else if(isBuffer$1(options.record_delimiter)){ + }else if(Buffer.isBuffer(options.record_delimiter)){ options.record_delimiter = options.record_delimiter.toString(); }else if(typeof options.record_delimiter !== 'string'){ return Error(`Invalid Option: record_delimiter must be a buffer or a string, got ${JSON.stringify(options.record_delimiter)}`); @@ -7086,8 +2057,8 @@ class Stringifier extends Transform { const stringify = function(records, options={}){ const data = []; - if(isBuffer$1(records)){ - const decoder = new StringDecoder(); + if(Buffer.isBuffer(records)){ + const decoder = new string_decoder.StringDecoder(); records = decoder.write(records); } function onData(record){ @@ -7118,7 +2089,7 @@ const Transformer = function(options = {}, handler){ options.params = null; } this.handler = handler; - Stream.Transform.call(this, this.options); + stream__default["default"].Transform.call(this, this.options); this.state = { running: 0, started: 0, @@ -7127,7 +2098,7 @@ const Transformer = function(options = {}, handler){ return this; }; -util.inherits(Transformer, Stream.Transform); +util__default["default"].inherits(Transformer, stream__default["default"].Transform); Transformer.prototype._transform = function(chunk, encoding, cb){ this.state.started++; diff --git a/packages/csv/dist/esm/index.js b/packages/csv/dist/esm/index.js index f3791726a..e6c115256 100644 --- a/packages/csv/dist/esm/index.js +++ b/packages/csv/dist/esm/index.js @@ -5259,7 +5259,7 @@ class ResizeableBuffer{ constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ if(isBuffer$1(val)){ @@ -5271,7 +5271,7 @@ class ResizeableBuffer{ } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5298,7 +5298,7 @@ class ResizeableBuffer{ resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } diff --git a/packages/csv/dist/esm/sync.js b/packages/csv/dist/esm/sync.js index f0b98fe12..ed8b0856b 100644 --- a/packages/csv/dist/esm/sync.js +++ b/packages/csv/dist/esm/sync.js @@ -5256,7 +5256,7 @@ class ResizeableBuffer{ constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ if(isBuffer$1(val)){ @@ -5268,7 +5268,7 @@ class ResizeableBuffer{ } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5295,7 +5295,7 @@ class ResizeableBuffer{ resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } diff --git a/packages/csv/dist/iife/index.js b/packages/csv/dist/iife/index.js index 33db8b173..bbd4cef31 100644 --- a/packages/csv/dist/iife/index.js +++ b/packages/csv/dist/iife/index.js @@ -5262,7 +5262,7 @@ var csv = (function (exports) { constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ if(isBuffer$1(val)){ @@ -5274,7 +5274,7 @@ var csv = (function (exports) { } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5301,7 +5301,7 @@ var csv = (function (exports) { resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } diff --git a/packages/csv/dist/iife/sync.js b/packages/csv/dist/iife/sync.js index 4dedffe46..695e530f4 100644 --- a/packages/csv/dist/iife/sync.js +++ b/packages/csv/dist/iife/sync.js @@ -5259,7 +5259,7 @@ var csv_sync = (function (exports) { constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ if(isBuffer$1(val)){ @@ -5271,7 +5271,7 @@ var csv_sync = (function (exports) { } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5298,7 +5298,7 @@ var csv_sync = (function (exports) { resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } diff --git a/packages/csv/dist/umd/index.js b/packages/csv/dist/umd/index.js index dfe2e8a77..fdd6d4bc6 100644 --- a/packages/csv/dist/umd/index.js +++ b/packages/csv/dist/umd/index.js @@ -5265,7 +5265,7 @@ constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ if(isBuffer$1(val)){ @@ -5277,7 +5277,7 @@ } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5304,7 +5304,7 @@ resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } diff --git a/packages/csv/dist/umd/sync.js b/packages/csv/dist/umd/sync.js index 5d32110d6..83608ded4 100644 --- a/packages/csv/dist/umd/sync.js +++ b/packages/csv/dist/umd/sync.js @@ -5262,7 +5262,7 @@ constructor(size=100){ this.size = size; this.length = 0; - this.buf = Buffer.alloc(size); + this.buf = Buffer.allocUnsafe(size); } prepend(val){ if(isBuffer$1(val)){ @@ -5274,7 +5274,7 @@ } } const buf = this.buf; - this.buf = Buffer.alloc(this.size); + this.buf = Buffer.allocUnsafe(this.size); val.copy(this.buf, 0); buf.copy(this.buf, val.length); this.length += val.length; @@ -5301,7 +5301,7 @@ resize(){ const length = this.length; this.size = this.size * 2; - const buf = Buffer.alloc(this.size); + const buf = Buffer.allocUnsafe(this.size); this.buf.copy(buf,0, 0, length); this.buf = buf; } diff --git a/packages/csv/rollup.config.js b/packages/csv/rollup.config.js index a2ff27109..0263b9dcf 100644 --- a/packages/csv/rollup.config.js +++ b/packages/csv/rollup.config.js @@ -14,10 +14,6 @@ export default [{ }, input: 'lib/index.js', output: [ - { - file: `dist/cjs/index.cjs`, - format: 'cjs' - }, { file: `dist/esm/index.js`, format: 'esm' @@ -36,6 +32,17 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/index.js', + output: [ + { + file: `dist/cjs/index.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }, { onwarn: function(warning, rollupWarn) { if (warning.code === 'CIRCULAR_DEPENDENCY') return; @@ -43,10 +50,6 @@ export default [{ }, input: 'lib/sync.js', output: [ - { - file: `dist/cjs/sync.cjs`, - format: 'cjs' - }, { file: `dist/esm/sync.js`, format: 'esm' @@ -65,4 +68,15 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/sync.js', + output: [ + { + file: `dist/cjs/sync.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }]; diff --git a/packages/stream-transform/dist/cjs/index.cjs b/packages/stream-transform/dist/cjs/index.cjs index 605f007fa..fa22650b4 100644 --- a/packages/stream-transform/dist/cjs/index.cjs +++ b/packages/stream-transform/dist/cjs/index.cjs @@ -2,5043 +2,13 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var domain; +var stream = require('stream'); +var util = require('util'); -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); - -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer$1; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer$1(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNullOrUndefined(arg) { - return arg == null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isSymbol(arg) { - return typeof arg === 'symbol'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function isPrimitive(arg) { - return arg === null || - typeof arg === 'boolean' || - typeof arg === 'number' || - typeof arg === 'string' || - typeof arg === 'symbol' || // ES6 symbol - typeof arg === 'undefined'; -} - -function isBuffer(maybeBuf) { - return isBuffer$1(maybeBuf); -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - - -function pad(n) { - return n < 10 ? '0' + n.toString(10) : n.toString(10); -} - - -var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', - 'Oct', 'Nov', 'Dec']; - -// 26 Feb 16:19:34 -function timestamp() { - var d = new Date(); - var time = [pad(d.getHours()), - pad(d.getMinutes()), - pad(d.getSeconds())].join(':'); - return [d.getDate(), months[d.getMonth()], time].join(' '); -} - - -// log is just a thin wrapper to console.log that prepends a timestamp -function log() { - console.log('%s - %s', timestamp(), format.apply(null, arguments)); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -var util = { - inherits: inherits$1, - _extend: _extend, - log: log, - isBuffer: isBuffer, - isPrimitive: isPrimitive, - isFunction: isFunction, - isError: isError, - isDate: isDate, - isObject: isObject, - isRegExp: isRegExp, - isUndefined: isUndefined, - isSymbol: isSymbol, - isString: isString, - isNumber: isNumber, - isNullOrUndefined: isNullOrUndefined, - isNull: isNull, - isBoolean: isBoolean, - isArray: isArray, - inspect: inspect, - deprecate: deprecate, - format: format, - debuglog: debuglog -}; - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer$1(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream); +var util__default = /*#__PURE__*/_interopDefaultLegacy(util); const Transformer = function(options = {}, handler){ this.options = options; @@ -5053,7 +23,7 @@ const Transformer = function(options = {}, handler){ options.params = null; } this.handler = handler; - Stream.Transform.call(this, this.options); + stream__default["default"].Transform.call(this, this.options); this.state = { running: 0, started: 0, @@ -5062,7 +32,7 @@ const Transformer = function(options = {}, handler){ return this; }; -util.inherits(Transformer, Stream.Transform); +util__default["default"].inherits(Transformer, stream__default["default"].Transform); Transformer.prototype._transform = function(chunk, encoding, cb){ this.state.started++; diff --git a/packages/stream-transform/dist/cjs/sync.cjs b/packages/stream-transform/dist/cjs/sync.cjs index 452c7c85a..bfefe5db4 100644 --- a/packages/stream-transform/dist/cjs/sync.cjs +++ b/packages/stream-transform/dist/cjs/sync.cjs @@ -2,5043 +2,13 @@ Object.defineProperty(exports, '__esModule', { value: true }); -var domain; +var stream = require('stream'); +var util = require('util'); -// This constructor is used to store event handlers. Instantiating this is -// faster than explicitly calling `Object.create(null)` to get a "clean" empty -// object (tested with v8 v4.9). -function EventHandlers() {} -EventHandlers.prototype = Object.create(null); +function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } -function EventEmitter() { - EventEmitter.init.call(this); -} - -// nodejs oddity -// require('events') === require('events').EventEmitter -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.prototype.domain = undefined; -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -EventEmitter.defaultMaxListeners = 10; - -EventEmitter.init = function() { - this.domain = null; - if (EventEmitter.usingDomains) { - // if there is an active domain, then attach to it. - if (domain.active ) ; - } - - if (!this._events || this._events === Object.getPrototypeOf(this)._events) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; -}; - -// Obviously not all Emitters should be limited to 10. This function allows -// that to be increased. Set to zero for unlimited. -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || isNaN(n)) - throw new TypeError('"n" argument must be a positive number'); - this._maxListeners = n; - return this; -}; - -function $getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return $getMaxListeners(this); -}; - -// These standalone emit* functions are used to optimize calling of event -// handlers for fast cases because emit() itself often has a variable number of -// arguments and can be deoptimized because of that. These functions always have -// the same number of arguments and thus do not get deoptimized, so the code -// inside them can execute faster. -function emitNone(handler, isFn, self) { - if (isFn) - handler.call(self); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self); - } -} -function emitOne(handler, isFn, self, arg1) { - if (isFn) - handler.call(self, arg1); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1); - } -} -function emitTwo(handler, isFn, self, arg1, arg2) { - if (isFn) - handler.call(self, arg1, arg2); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2); - } -} -function emitThree(handler, isFn, self, arg1, arg2, arg3) { - if (isFn) - handler.call(self, arg1, arg2, arg3); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].call(self, arg1, arg2, arg3); - } -} - -function emitMany(handler, isFn, self, args) { - if (isFn) - handler.apply(self, args); - else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - listeners[i].apply(self, args); - } -} - -EventEmitter.prototype.emit = function emit(type) { - var er, handler, len, args, i, events, domain; - var doError = (type === 'error'); - - events = this._events; - if (events) - doError = (doError && events.error == null); - else if (!doError) - return false; - - domain = this.domain; - - // If there is no 'error' event listener then throw. - if (doError) { - er = arguments[1]; - if (domain) { - if (!er) - er = new Error('Uncaught, unspecified "error" event'); - er.domainEmitter = this; - er.domain = domain; - er.domainThrown = false; - domain.emit('error', er); - } else if (er instanceof Error) { - throw er; // Unhandled 'error' event - } else { - // At least give some kind of context to the user - var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); - err.context = er; - throw err; - } - return false; - } - - handler = events[type]; - - if (!handler) - return false; - - var isFn = typeof handler === 'function'; - len = arguments.length; - switch (len) { - // fast cases - case 1: - emitNone(handler, isFn, this); - break; - case 2: - emitOne(handler, isFn, this, arguments[1]); - break; - case 3: - emitTwo(handler, isFn, this, arguments[1], arguments[2]); - break; - case 4: - emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]); - break; - // slower - default: - args = new Array(len - 1); - for (i = 1; i < len; i++) - args[i - 1] = arguments[i]; - emitMany(handler, isFn, this, args); - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = target._events; - if (!events) { - events = target._events = new EventHandlers(); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (!existing) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = prepend ? [listener, existing] : - [existing, listener]; - } else { - // If we've already got an array, just append. - if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - } - - // Check for listener leak - if (!existing.warned) { - m = $getMaxListeners(target); - if (m && m > 0 && existing.length > m) { - existing.warned = true; - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + type + ' listeners added. ' + - 'Use emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - emitWarning(w); - } - } - } - - return target; -} -function emitWarning(e) { - typeof console.warn === 'function' ? console.warn(e) : console.log(e); -} -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function _onceWrap(target, type, listener) { - var fired = false; - function g() { - target.removeListener(type, g); - if (!fired) { - fired = true; - listener.apply(target, arguments); - } - } - g.listener = listener; - return g; -} - -EventEmitter.prototype.once = function once(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - -// emits a 'removeListener' event iff the listener was removed -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - if (typeof listener !== 'function') - throw new TypeError('"listener" argument must be a function'); - - events = this._events; - if (!events) - return this; - - list = events[type]; - if (!list) - return this; - - if (list === listener || (list.listener && list.listener === listener)) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length; i-- > 0;) { - if (list[i] === listener || - (list[i].listener && list[i].listener === listener)) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (list.length === 1) { - list[0] = undefined; - if (--this._eventsCount === 0) { - this._events = new EventHandlers(); - return this; - } else { - delete events[type]; - } - } else { - spliceOne(list, position); - } - - if (events.removeListener) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events; - - events = this._events; - if (!events) - return this; - - // not listening for removeListener, no need to emit - if (!events.removeListener) { - if (arguments.length === 0) { - this._events = new EventHandlers(); - this._eventsCount = 0; - } else if (events[type]) { - if (--this._eventsCount === 0) - this._events = new EventHandlers(); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - for (var i = 0, key; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = new EventHandlers(); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners) { - // LIFO order - do { - this.removeListener(type, listeners[listeners.length - 1]); - } while (listeners[0]); - } - - return this; - }; - -EventEmitter.prototype.listeners = function listeners(type) { - var evlistener; - var ret; - var events = this._events; - - if (!events) - ret = []; - else { - evlistener = events[type]; - if (!evlistener) - ret = []; - else if (typeof evlistener === 'function') - ret = [evlistener.listener || evlistener]; - else - ret = unwrapListeners(evlistener); - } - - return ret; -}; - -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount$1.call(emitter, type); - } -}; - -EventEmitter.prototype.listenerCount = listenerCount$1; -function listenerCount$1(type) { - var events = this._events; - - if (events) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener) { - return evlistener.length; - } - } - - return 0; -} - -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : []; -}; - -// About 1.5x faster than the two-arg version of Array#splice(). -function spliceOne(list, index) { - for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) - list[i] = list[k]; - list.pop(); -} - -function arrayClone(arr, i) { - var copy = new Array(i); - while (i--) - copy[i] = arr[i]; - return copy; -} - -function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; -} - -var global$1 = (typeof global !== "undefined" ? global : - typeof self !== "undefined" ? self : - typeof window !== "undefined" ? window : {}); - -var lookup = []; -var revLookup = []; -var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array; -var inited = false; -function init () { - inited = true; - var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - for (var i = 0, len = code.length; i < len; ++i) { - lookup[i] = code[i]; - revLookup[code.charCodeAt(i)] = i; - } - - revLookup['-'.charCodeAt(0)] = 62; - revLookup['_'.charCodeAt(0)] = 63; -} - -function toByteArray (b64) { - if (!inited) { - init(); - } - var i, j, l, tmp, placeHolders, arr; - var len = b64.length; - - if (len % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0; - - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(len * 3 / 4 - placeHolders); - - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? len - 4 : len; - - var L = 0; - - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)]; - arr[L++] = (tmp >> 16) & 0xFF; - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - if (placeHolders === 2) { - tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4); - arr[L++] = tmp & 0xFF; - } else if (placeHolders === 1) { - tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2); - arr[L++] = (tmp >> 8) & 0xFF; - arr[L++] = tmp & 0xFF; - } - - return arr -} - -function tripletToBase64 (num) { - return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F] -} - -function encodeChunk (uint8, start, end) { - var tmp; - var output = []; - for (var i = start; i < end; i += 3) { - tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]); - output.push(tripletToBase64(tmp)); - } - return output.join('') -} - -function fromByteArray (uint8) { - if (!inited) { - init(); - } - var tmp; - var len = uint8.length; - var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes - var output = ''; - var parts = []; - var maxChunkLength = 16383; // must be multiple of 3 - - // go through the array every three bytes, we'll deal with trailing stuff later - for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { - parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength))); - } - - // pad the end with zeros, but make sure to not forget the extra bytes - if (extraBytes === 1) { - tmp = uint8[len - 1]; - output += lookup[tmp >> 2]; - output += lookup[(tmp << 4) & 0x3F]; - output += '=='; - } else if (extraBytes === 2) { - tmp = (uint8[len - 2] << 8) + (uint8[len - 1]); - output += lookup[tmp >> 10]; - output += lookup[(tmp >> 4) & 0x3F]; - output += lookup[(tmp << 2) & 0x3F]; - output += '='; - } - - parts.push(output); - - return parts.join('') -} - -function read (buffer, offset, isLE, mLen, nBytes) { - var e, m; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var nBits = -7; - var i = isLE ? (nBytes - 1) : 0; - var d = isLE ? -1 : 1; - var s = buffer[offset + i]; - - i += d; - - e = s & ((1 << (-nBits)) - 1); - s >>= (-nBits); - nBits += eLen; - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - m = e & ((1 << (-nBits)) - 1); - e >>= (-nBits); - nBits += mLen; - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} - - if (e === 0) { - e = 1 - eBias; - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen); - e = e - eBias; - } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) -} - -function write (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c; - var eLen = nBytes * 8 - mLen - 1; - var eMax = (1 << eLen) - 1; - var eBias = eMax >> 1; - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0); - var i = isLE ? 0 : (nBytes - 1); - var d = isLE ? 1 : -1; - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0; - - value = Math.abs(value); - - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0; - e = eMax; - } else { - e = Math.floor(Math.log(value) / Math.LN2); - if (value * (c = Math.pow(2, -e)) < 1) { - e--; - c *= 2; - } - if (e + eBias >= 1) { - value += rt / c; - } else { - value += rt * Math.pow(2, 1 - eBias); - } - if (value * c >= 2) { - e++; - c /= 2; - } - - if (e + eBias >= eMax) { - m = 0; - e = eMax; - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen); - e = e + eBias; - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); - e = 0; - } - } - - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} - - e = (e << mLen) | m; - eLen += mLen; - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} - - buffer[offset + i - d] |= s * 128; -} - -var toString = {}.toString; - -var isArray$1 = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; -}; - -var INSPECT_MAX_BYTES = 50; - -/** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. - - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ -Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined - ? global$1.TYPED_ARRAY_SUPPORT - : true; - -function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff -} - -function createBuffer (that, length) { - if (kMaxLength() < length) { - throw new RangeError('Invalid typed array length') - } - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = new Uint8Array(length); - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - if (that === null) { - that = new Buffer(length); - } - that.length = length; - } - - return that -} - -/** - * The Buffer constructor returns instances of `Uint8Array` that have their - * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of - * `Uint8Array`, so the returned instances will have all the node `Buffer` methods - * and the `Uint8Array` methods. Square bracket notation works as expected -- it - * returns a single octet. - * - * The `Uint8Array` prototype remains unmodified. - */ - -function Buffer (arg, encodingOrOffset, length) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { - return new Buffer(arg, encodingOrOffset, length) - } - - // Common case. - if (typeof arg === 'number') { - if (typeof encodingOrOffset === 'string') { - throw new Error( - 'If encoding is specified then the first argument must be a string' - ) - } - return allocUnsafe(this, arg) - } - return from(this, arg, encodingOrOffset, length) -} - -Buffer.poolSize = 8192; // not used by this implementation - -// TODO: Legacy, not needed anymore. Remove in next major version. -Buffer._augment = function (arr) { - arr.__proto__ = Buffer.prototype; - return arr -}; - -function from (that, value, encodingOrOffset, length) { - if (typeof value === 'number') { - throw new TypeError('"value" argument must not be a number') - } - - if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { - return fromArrayBuffer(that, value, encodingOrOffset, length) - } - - if (typeof value === 'string') { - return fromString(that, value, encodingOrOffset) - } - - return fromObject(that, value) -} - -/** - * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError - * if value is a number. - * Buffer.from(str[, encoding]) - * Buffer.from(array) - * Buffer.from(buffer) - * Buffer.from(arrayBuffer[, byteOffset[, length]]) - **/ -Buffer.from = function (value, encodingOrOffset, length) { - return from(null, value, encodingOrOffset, length) -}; - -if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype; - Buffer.__proto__ = Uint8Array; -} - -function assertSize (size) { - if (typeof size !== 'number') { - throw new TypeError('"size" argument must be a number') - } else if (size < 0) { - throw new RangeError('"size" argument must not be negative') - } -} - -function alloc (that, size, fill, encoding) { - assertSize(size); - if (size <= 0) { - return createBuffer(that, size) - } - if (fill !== undefined) { - // Only pay attention to encoding if it's a string. This - // prevents accidentally sending in a number that would - // be interpretted as a start offset. - return typeof encoding === 'string' - ? createBuffer(that, size).fill(fill, encoding) - : createBuffer(that, size).fill(fill) - } - return createBuffer(that, size) -} - -/** - * Creates a new filled Buffer instance. - * alloc(size[, fill[, encoding]]) - **/ -Buffer.alloc = function (size, fill, encoding) { - return alloc(null, size, fill, encoding) -}; - -function allocUnsafe (that, size) { - assertSize(size); - that = createBuffer(that, size < 0 ? 0 : checked(size) | 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < size; ++i) { - that[i] = 0; - } - } - return that -} - -/** - * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. - * */ -Buffer.allocUnsafe = function (size) { - return allocUnsafe(null, size) -}; -/** - * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. - */ -Buffer.allocUnsafeSlow = function (size) { - return allocUnsafe(null, size) -}; - -function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') { - encoding = 'utf8'; - } - - if (!Buffer.isEncoding(encoding)) { - throw new TypeError('"encoding" must be a valid string encoding') - } - - var length = byteLength(string, encoding) | 0; - that = createBuffer(that, length); - - var actual = that.write(string, encoding); - - if (actual !== length) { - // Writing a hex string, for example, that contains invalid characters will - // cause everything after the first invalid character to be ignored. (e.g. - // 'abxxcd' will be treated as 'ab') - that = that.slice(0, actual); - } - - return that -} - -function fromArrayLike (that, array) { - var length = array.length < 0 ? 0 : checked(array.length) | 0; - that = createBuffer(that, length); - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255; - } - return that -} - -function fromArrayBuffer (that, array, byteOffset, length) { - array.byteLength; // this throws if `array` is not a valid ArrayBuffer - - if (byteOffset < 0 || array.byteLength < byteOffset) { - throw new RangeError('\'offset\' is out of bounds') - } - - if (array.byteLength < byteOffset + (length || 0)) { - throw new RangeError('\'length\' is out of bounds') - } - - if (byteOffset === undefined && length === undefined) { - array = new Uint8Array(array); - } else if (length === undefined) { - array = new Uint8Array(array, byteOffset); - } else { - array = new Uint8Array(array, byteOffset, length); - } - - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = array; - that.__proto__ = Buffer.prototype; - } else { - // Fallback: Return an object instance of the Buffer class - that = fromArrayLike(that, array); - } - return that -} - -function fromObject (that, obj) { - if (internalIsBuffer(obj)) { - var len = checked(obj.length) | 0; - that = createBuffer(that, len); - - if (that.length === 0) { - return that - } - - obj.copy(that, 0, 0, len); - return that - } - - if (obj) { - if ((typeof ArrayBuffer !== 'undefined' && - obj.buffer instanceof ArrayBuffer) || 'length' in obj) { - if (typeof obj.length !== 'number' || isnan(obj.length)) { - return createBuffer(that, 0) - } - return fromArrayLike(that, obj) - } - - if (obj.type === 'Buffer' && isArray$1(obj.data)) { - return fromArrayLike(that, obj.data) - } - } - - throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') -} - -function checked (length) { - // Note: cannot use `length < kMaxLength()` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 -} -Buffer.isBuffer = isBuffer$1; -function internalIsBuffer (b) { - return !!(b != null && b._isBuffer) -} - -Buffer.compare = function compare (a, b) { - if (!internalIsBuffer(a) || !internalIsBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } - - if (a === b) return 0 - - var x = a.length; - var y = b.length; - - for (var i = 0, len = Math.min(x, y); i < len; ++i) { - if (a[i] !== b[i]) { - x = a[i]; - y = b[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'latin1': - case 'binary': - case 'base64': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false - } -}; - -Buffer.concat = function concat (list, length) { - if (!isArray$1(list)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - - if (list.length === 0) { - return Buffer.alloc(0) - } - - var i; - if (length === undefined) { - length = 0; - for (i = 0; i < list.length; ++i) { - length += list[i].length; - } - } - - var buffer = Buffer.allocUnsafe(length); - var pos = 0; - for (i = 0; i < list.length; ++i) { - var buf = list[i]; - if (!internalIsBuffer(buf)) { - throw new TypeError('"list" argument must be an Array of Buffers') - } - buf.copy(buffer, pos); - pos += buf.length; - } - return buffer -}; - -function byteLength (string, encoding) { - if (internalIsBuffer(string)) { - return string.length - } - if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && - (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { - return string.byteLength - } - if (typeof string !== 'string') { - string = '' + string; - } - - var len = string.length; - if (len === 0) return 0 - - // Use a for loop to avoid recursion - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'ascii': - case 'latin1': - case 'binary': - return len - case 'utf8': - case 'utf-8': - case undefined: - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -} -Buffer.byteLength = byteLength; - -function slowToString (encoding, start, end) { - var loweredCase = false; - - // No need to verify that "this.length <= MAX_UINT32" since it's a read-only - // property of a typed array. - - // This behaves neither like String nor Uint8Array in that we set start/end - // to their upper/lower bounds if the value passed is out of range. - // undefined is handled specially as per ECMA-262 6th Edition, - // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. - if (start === undefined || start < 0) { - start = 0; - } - // Return early if start > this.length. Done here to prevent potential uint32 - // coercion fail below. - if (start > this.length) { - return '' - } - - if (end === undefined || end > this.length) { - end = this.length; - } - - if (end <= 0) { - return '' - } - - // Force coersion to uint32. This will also coerce falsey/NaN values to 0. - end >>>= 0; - start >>>= 0; - - if (end <= start) { - return '' - } - - if (!encoding) encoding = 'utf8'; - - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) - - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) - - case 'ascii': - return asciiSlice(this, start, end) - - case 'latin1': - case 'binary': - return latin1Slice(this, start, end) - - case 'base64': - return base64Slice(this, start, end) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase(); - loweredCase = true; - } - } -} - -// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect -// Buffer instances. -Buffer.prototype._isBuffer = true; - -function swap (b, n, m) { - var i = b[n]; - b[n] = b[m]; - b[m] = i; -} - -Buffer.prototype.swap16 = function swap16 () { - var len = this.length; - if (len % 2 !== 0) { - throw new RangeError('Buffer size must be a multiple of 16-bits') - } - for (var i = 0; i < len; i += 2) { - swap(this, i, i + 1); - } - return this -}; - -Buffer.prototype.swap32 = function swap32 () { - var len = this.length; - if (len % 4 !== 0) { - throw new RangeError('Buffer size must be a multiple of 32-bits') - } - for (var i = 0; i < len; i += 4) { - swap(this, i, i + 3); - swap(this, i + 1, i + 2); - } - return this -}; - -Buffer.prototype.swap64 = function swap64 () { - var len = this.length; - if (len % 8 !== 0) { - throw new RangeError('Buffer size must be a multiple of 64-bits') - } - for (var i = 0; i < len; i += 8) { - swap(this, i, i + 7); - swap(this, i + 1, i + 6); - swap(this, i + 2, i + 5); - swap(this, i + 3, i + 4); - } - return this -}; - -Buffer.prototype.toString = function toString () { - var length = this.length | 0; - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) -}; - -Buffer.prototype.equals = function equals (b) { - if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 -}; - -Buffer.prototype.inspect = function inspect () { - var str = ''; - var max = INSPECT_MAX_BYTES; - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' '); - if (this.length > max) str += ' ... '; - } - return '' -}; - -Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { - if (!internalIsBuffer(target)) { - throw new TypeError('Argument must be a Buffer') - } - - if (start === undefined) { - start = 0; - } - if (end === undefined) { - end = target ? target.length : 0; - } - if (thisStart === undefined) { - thisStart = 0; - } - if (thisEnd === undefined) { - thisEnd = this.length; - } - - if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { - throw new RangeError('out of range index') - } - - if (thisStart >= thisEnd && start >= end) { - return 0 - } - if (thisStart >= thisEnd) { - return -1 - } - if (start >= end) { - return 1 - } - - start >>>= 0; - end >>>= 0; - thisStart >>>= 0; - thisEnd >>>= 0; - - if (this === target) return 0 - - var x = thisEnd - thisStart; - var y = end - start; - var len = Math.min(x, y); - - var thisCopy = this.slice(thisStart, thisEnd); - var targetCopy = target.slice(start, end); - - for (var i = 0; i < len; ++i) { - if (thisCopy[i] !== targetCopy[i]) { - x = thisCopy[i]; - y = targetCopy[i]; - break - } - } - - if (x < y) return -1 - if (y < x) return 1 - return 0 -}; - -// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, -// OR the last index of `val` in `buffer` at offset <= `byteOffset`. -// -// Arguments: -// - buffer - a Buffer to search -// - val - a string, Buffer, or number -// - byteOffset - an index into `buffer`; will be clamped to an int32 -// - encoding - an optional encoding, relevant is val is a string -// - dir - true for indexOf, false for lastIndexOf -function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { - // Empty buffer means no match - if (buffer.length === 0) return -1 - - // Normalize byteOffset - if (typeof byteOffset === 'string') { - encoding = byteOffset; - byteOffset = 0; - } else if (byteOffset > 0x7fffffff) { - byteOffset = 0x7fffffff; - } else if (byteOffset < -0x80000000) { - byteOffset = -0x80000000; - } - byteOffset = +byteOffset; // Coerce to Number. - if (isNaN(byteOffset)) { - // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer - byteOffset = dir ? 0 : (buffer.length - 1); - } - - // Normalize byteOffset: negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = buffer.length + byteOffset; - if (byteOffset >= buffer.length) { - if (dir) return -1 - else byteOffset = buffer.length - 1; - } else if (byteOffset < 0) { - if (dir) byteOffset = 0; - else return -1 - } - - // Normalize val - if (typeof val === 'string') { - val = Buffer.from(val, encoding); - } - - // Finally, search either indexOf (if dir is true) or lastIndexOf - if (internalIsBuffer(val)) { - // Special case: looking for empty string/buffer always fails - if (val.length === 0) { - return -1 - } - return arrayIndexOf(buffer, val, byteOffset, encoding, dir) - } else if (typeof val === 'number') { - val = val & 0xFF; // Search for a byte value [0-255] - if (Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf === 'function') { - if (dir) { - return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) - } else { - return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) - } - } - return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) - } - - throw new TypeError('val must be string, number or Buffer') -} - -function arrayIndexOf (arr, val, byteOffset, encoding, dir) { - var indexSize = 1; - var arrLength = arr.length; - var valLength = val.length; - - if (encoding !== undefined) { - encoding = String(encoding).toLowerCase(); - if (encoding === 'ucs2' || encoding === 'ucs-2' || - encoding === 'utf16le' || encoding === 'utf-16le') { - if (arr.length < 2 || val.length < 2) { - return -1 - } - indexSize = 2; - arrLength /= 2; - valLength /= 2; - byteOffset /= 2; - } - } - - function read (buf, i) { - if (indexSize === 1) { - return buf[i] - } else { - return buf.readUInt16BE(i * indexSize) - } - } - - var i; - if (dir) { - var foundIndex = -1; - for (i = byteOffset; i < arrLength; i++) { - if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { - if (foundIndex === -1) foundIndex = i; - if (i - foundIndex + 1 === valLength) return foundIndex * indexSize - } else { - if (foundIndex !== -1) i -= i - foundIndex; - foundIndex = -1; - } - } - } else { - if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; - for (i = byteOffset; i >= 0; i--) { - var found = true; - for (var j = 0; j < valLength; j++) { - if (read(arr, i + j) !== read(val, j)) { - found = false; - break - } - } - if (found) return i - } - } - - return -1 -} - -Buffer.prototype.includes = function includes (val, byteOffset, encoding) { - return this.indexOf(val, byteOffset, encoding) !== -1 -}; - -Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, true) -}; - -Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { - return bidirectionalIndexOf(this, val, byteOffset, encoding, false) -}; - -function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0; - var remaining = buf.length - offset; - if (!length) { - length = remaining; - } else { - length = Number(length); - if (length > remaining) { - length = remaining; - } - } - - // must be an even number of digits - var strLen = string.length; - if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') - - if (length > strLen / 2) { - length = strLen / 2; - } - for (var i = 0; i < length; ++i) { - var parsed = parseInt(string.substr(i * 2, 2), 16); - if (isNaN(parsed)) return i - buf[offset + i] = parsed; - } - return i -} - -function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) -} - -function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) -} - -function latin1Write (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) -} - -function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) -} - -function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) -} - -Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8'; - length = this.length; - offset = 0; - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset; - length = this.length; - offset = 0; - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0; - if (isFinite(length)) { - length = length | 0; - if (encoding === undefined) encoding = 'utf8'; - } else { - encoding = length; - length = undefined; - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - throw new Error( - 'Buffer.write(string, encoding, offset[, length]) is no longer supported' - ) - } - - var remaining = this.length - offset; - if (length === undefined || length > remaining) length = remaining; - - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('Attempt to write outside buffer bounds') - } - - if (!encoding) encoding = 'utf8'; - - var loweredCase = false; - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) - - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) - - case 'ascii': - return asciiWrite(this, string, offset, length) - - case 'latin1': - case 'binary': - return latin1Write(this, string, offset, length) - - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) - - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) - - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase(); - loweredCase = true; - } - } -}; - -Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } -}; - -function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return fromByteArray(buf) - } else { - return fromByteArray(buf.slice(start, end)) - } -} - -function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end); - var res = []; - - var i = start; - while (i < end) { - var firstByte = buf[i]; - var codePoint = null; - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1; - - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint; - - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte; - } - break - case 2: - secondByte = buf[i + 1]; - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F); - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint; - } - } - break - case 3: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F); - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint; - } - } - break - case 4: - secondByte = buf[i + 1]; - thirdByte = buf[i + 2]; - fourthByte = buf[i + 3]; - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F); - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint; - } - } - } - } - - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD; - bytesPerSequence = 1; - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000; - res.push(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - - res.push(codePoint); - i += bytesPerSequence; - } - - return decodeCodePointsArray(res) -} - -// Based on http://stackoverflow.com/a/22747272/680742, the browser with -// the lowest limit is Chrome, with 0x10000 args. -// We go 1 magnitude less, for safety -var MAX_ARGUMENTS_LENGTH = 0x1000; - -function decodeCodePointsArray (codePoints) { - var len = codePoints.length; - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } - - // Decode in chunks to avoid "call stack size exceeded". - var res = ''; - var i = 0; - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ); - } - return res -} - -function asciiSlice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i] & 0x7F); - } - return ret -} - -function latin1Slice (buf, start, end) { - var ret = ''; - end = Math.min(buf.length, end); - - for (var i = start; i < end; ++i) { - ret += String.fromCharCode(buf[i]); - } - return ret -} - -function hexSlice (buf, start, end) { - var len = buf.length; - - if (!start || start < 0) start = 0; - if (!end || end < 0 || end > len) end = len; - - var out = ''; - for (var i = start; i < end; ++i) { - out += toHex(buf[i]); - } - return out -} - -function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end); - var res = ''; - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); - } - return res -} - -Buffer.prototype.slice = function slice (start, end) { - var len = this.length; - start = ~~start; - end = end === undefined ? len : ~~end; - - if (start < 0) { - start += len; - if (start < 0) start = 0; - } else if (start > len) { - start = len; - } - - if (end < 0) { - end += len; - if (end < 0) end = 0; - } else if (end > len) { - end = len; - } - - if (end < start) end = start; - - var newBuf; - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = this.subarray(start, end); - newBuf.__proto__ = Buffer.prototype; - } else { - var sliceLen = end - start; - newBuf = new Buffer(sliceLen, undefined); - for (var i = 0; i < sliceLen; ++i) { - newBuf[i] = this[i + start]; - } - } - - return newBuf -}; - -/* - * Need to make sure that buffer isn't trying to write out of bounds. - */ -function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') -} - -Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - - return val -}; - -Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - checkOffset(offset, byteLength, this.length); - } - - var val = this[offset + --byteLength]; - var mul = 1; - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul; - } - - return val -}; - -Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - return this[offset] -}; - -Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return this[offset] | (this[offset + 1] << 8) -}; - -Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - return (this[offset] << 8) | this[offset + 1] -}; - -Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) -}; - -Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) -}; - -Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var val = this[offset]; - var mul = 1; - var i = 0; - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) checkOffset(offset, byteLength, this.length); - - var i = byteLength; - var mul = 1; - var val = this[offset + --i]; - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul; - } - mul *= 0x80; - - if (val >= mul) val -= Math.pow(2, 8 * byteLength); - - return val -}; - -Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length); - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) -}; - -Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset] | (this[offset + 1] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length); - var val = this[offset + 1] | (this[offset] << 8); - return (val & 0x8000) ? val | 0xFFFF0000 : val -}; - -Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) -}; - -Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) -}; - -Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, true, 23, 4) -}; - -Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length); - return read(this, offset, false, 23, 4) -}; - -Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, true, 52, 8) -}; - -Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length); - return read(this, offset, false, 52, 8) -}; - -function checkInt (buf, value, offset, ext, max, min) { - if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') - if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') - if (offset + ext > buf.length) throw new RangeError('Index out of range') -} - -Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var mul = 1; - var i = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - byteLength = byteLength | 0; - if (!noAssert) { - var maxBytes = Math.pow(2, 8 * byteLength) - 1; - checkInt(this, value, offset, byteLength, maxBytes, 0); - } - - var i = byteLength - 1; - var mul = 1; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - this[offset] = (value & 0xff); - return offset + 1 -}; - -function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8; - } -} - -Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -function objectWriteUInt32 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffffffff + value + 1; - for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { - buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff; - } -} - -Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24); - this[offset + 2] = (value >>> 16); - this[offset + 1] = (value >>> 8); - this[offset] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = 0; - var mul = 1; - var sub = 0; - this[offset] = value & 0xFF; - while (++i < byteLength && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1); - - checkInt(this, value, offset, byteLength, limit - 1, -limit); - } - - var i = byteLength - 1; - var mul = 1; - var sub = 0; - this[offset + i] = value & 0xFF; - while (--i >= 0 && (mul *= 0x100)) { - if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { - sub = 1; - } - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF; - } - - return offset + byteLength -}; - -Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80); - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value); - if (value < 0) value = 0xff + value + 1; - this[offset] = (value & 0xff); - return offset + 1 -}; - -Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - } else { - objectWriteUInt16(this, value, offset, true); - } - return offset + 2 -}; - -Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8); - this[offset + 1] = (value & 0xff); - } else { - objectWriteUInt16(this, value, offset, false); - } - return offset + 2 -}; - -Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff); - this[offset + 1] = (value >>> 8); - this[offset + 2] = (value >>> 16); - this[offset + 3] = (value >>> 24); - } else { - objectWriteUInt32(this, value, offset, true); - } - return offset + 4 -}; - -Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value; - offset = offset | 0; - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000); - if (value < 0) value = 0xffffffff + value + 1; - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24); - this[offset + 1] = (value >>> 16); - this[offset + 2] = (value >>> 8); - this[offset + 3] = (value & 0xff); - } else { - objectWriteUInt32(this, value, offset, false); - } - return offset + 4 -}; - -function checkIEEE754 (buf, value, offset, ext, max, min) { - if (offset + ext > buf.length) throw new RangeError('Index out of range') - if (offset < 0) throw new RangeError('Index out of range') -} - -function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4); - } - write(buf, value, offset, littleEndian, 23, 4); - return offset + 4 -} - -Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) -}; - -function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8); - } - write(buf, value, offset, littleEndian, 52, 8); - return offset + 8 -} - -Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) -}; - -Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) -}; - -// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) -Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0; - if (!end && end !== 0) end = this.length; - if (targetStart >= target.length) targetStart = target.length; - if (!targetStart) targetStart = 0; - if (end > 0 && end < start) end = start; - - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 - - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') - - // Are we oob? - if (end > this.length) end = this.length; - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start; - } - - var len = end - start; - var i; - - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; --i) { - target[i + targetStart] = this[i + start]; - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; ++i) { - target[i + targetStart] = this[i + start]; - } - } else { - Uint8Array.prototype.set.call( - target, - this.subarray(start, start + len), - targetStart - ); - } - - return len -}; - -// Usage: -// buffer.fill(number[, offset[, end]]) -// buffer.fill(buffer[, offset[, end]]) -// buffer.fill(string[, offset[, end]][, encoding]) -Buffer.prototype.fill = function fill (val, start, end, encoding) { - // Handle string cases: - if (typeof val === 'string') { - if (typeof start === 'string') { - encoding = start; - start = 0; - end = this.length; - } else if (typeof end === 'string') { - encoding = end; - end = this.length; - } - if (val.length === 1) { - var code = val.charCodeAt(0); - if (code < 256) { - val = code; - } - } - if (encoding !== undefined && typeof encoding !== 'string') { - throw new TypeError('encoding must be a string') - } - if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { - throw new TypeError('Unknown encoding: ' + encoding) - } - } else if (typeof val === 'number') { - val = val & 255; - } - - // Invalid ranges are not set to a default, so can range check early. - if (start < 0 || this.length < start || this.length < end) { - throw new RangeError('Out of range index') - } - - if (end <= start) { - return this - } - - start = start >>> 0; - end = end === undefined ? this.length : end >>> 0; - - if (!val) val = 0; - - var i; - if (typeof val === 'number') { - for (i = start; i < end; ++i) { - this[i] = val; - } - } else { - var bytes = internalIsBuffer(val) - ? val - : utf8ToBytes(new Buffer(val, encoding).toString()); - var len = bytes.length; - for (i = 0; i < end - start; ++i) { - this[i + start] = bytes[i % len]; - } - } - - return this -}; - -// HELPER FUNCTIONS -// ================ - -var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g; - -function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, ''); - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '='; - } - return str -} - -function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') -} - -function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) -} - -function utf8ToBytes (string, units) { - units = units || Infinity; - var codePoint; - var length = string.length; - var leadSurrogate = null; - var bytes = []; - - for (var i = 0; i < length; ++i) { - codePoint = string.charCodeAt(i); - - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - continue - } - - // valid lead - leadSurrogate = codePoint; - - continue - } - - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - leadSurrogate = codePoint; - continue - } - - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000; - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD); - } - - leadSurrogate = null; - - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint); - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ); - } else { - throw new Error('Invalid code point') - } - } - - return bytes -} - -function asciiToBytes (str) { - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF); - } - return byteArray -} - -function utf16leToBytes (str, units) { - var c, hi, lo; - var byteArray = []; - for (var i = 0; i < str.length; ++i) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i); - hi = c >> 8; - lo = c % 256; - byteArray.push(lo); - byteArray.push(hi); - } - - return byteArray -} - - -function base64ToBytes (str) { - return toByteArray(base64clean(str)) -} - -function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; ++i) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i]; - } - return i -} - -function isnan (val) { - return val !== val // eslint-disable-line no-self-compare -} - - -// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence -// The _isBuffer check is for Safari 5-7 support, because it's missing -// Object.prototype.constructor. Remove this eventually -function isBuffer$1(obj) { - return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj)) -} - -function isFastBuffer (obj) { - return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj) -} - -// For Node v0.10 support. Remove this eventually. -function isSlowBuffer (obj) { - return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0)) -} - -// shim for using process in browser -// based off https://github.com/defunctzombie/node-process/blob/master/browser.js - -function defaultSetTimout() { - throw new Error('setTimeout has not been defined'); -} -function defaultClearTimeout () { - throw new Error('clearTimeout has not been defined'); -} -var cachedSetTimeout = defaultSetTimout; -var cachedClearTimeout = defaultClearTimeout; -if (typeof global$1.setTimeout === 'function') { - cachedSetTimeout = setTimeout; -} -if (typeof global$1.clearTimeout === 'function') { - cachedClearTimeout = clearTimeout; -} - -function runTimeout(fun) { - if (cachedSetTimeout === setTimeout) { - //normal enviroments in sane situations - return setTimeout(fun, 0); - } - // if setTimeout wasn't available but was latter defined - if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { - cachedSetTimeout = setTimeout; - return setTimeout(fun, 0); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedSetTimeout(fun, 0); - } catch(e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedSetTimeout.call(null, fun, 0); - } catch(e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error - return cachedSetTimeout.call(this, fun, 0); - } - } - - -} -function runClearTimeout(marker) { - if (cachedClearTimeout === clearTimeout) { - //normal enviroments in sane situations - return clearTimeout(marker); - } - // if clearTimeout wasn't available but was latter defined - if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { - cachedClearTimeout = clearTimeout; - return clearTimeout(marker); - } - try { - // when when somebody has screwed with setTimeout but no I.E. maddness - return cachedClearTimeout(marker); - } catch (e){ - try { - // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally - return cachedClearTimeout.call(null, marker); - } catch (e){ - // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. - // Some versions of I.E. have different rules for clearTimeout vs setTimeout - return cachedClearTimeout.call(this, marker); - } - } - - - -} -var queue = []; -var draining = false; -var currentQueue; -var queueIndex = -1; - -function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } -} - -function drainQueue() { - if (draining) { - return; - } - var timeout = runTimeout(cleanUpNextTick); - draining = true; - - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - runClearTimeout(timeout); -} -function nextTick(fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - runTimeout(drainQueue); - } -} -// v8 likes predictible objects -function Item(fun, array) { - this.fun = fun; - this.array = array; -} -Item.prototype.run = function () { - this.fun.apply(null, this.array); -}; - -// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js -var performance = global$1.performance || {}; -performance.now || - performance.mozNow || - performance.msNow || - performance.oNow || - performance.webkitNow || - function(){ return (new Date()).getTime() }; - -var inherits; -if (typeof Object.create === 'function'){ - inherits = function inherits(ctor, superCtor) { - // implementation from standard node.js 'util' module - ctor.super_ = superCtor; - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); - }; -} else { - inherits = function inherits(ctor, superCtor) { - ctor.super_ = superCtor; - var TempCtor = function () {}; - TempCtor.prototype = superCtor.prototype; - ctor.prototype = new TempCtor(); - ctor.prototype.constructor = ctor; - }; -} -var inherits$1 = inherits; - -var formatRegExp = /%[sdj%]/g; -function format(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } - - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); - } - } - return str; -} - -// Mark that a method should not be used. -// Returns a modified function which warns once by default. -// If --no-deprecation is set, then it is a no-op. -function deprecate(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global$1.process)) { - return function() { - return deprecate(fn, msg).apply(this, arguments); - }; - } - - var warned = false; - function deprecated() { - if (!warned) { - { - console.error(msg); - } - warned = true; - } - return fn.apply(this, arguments); - } - - return deprecated; -} - -var debugs = {}; -var debugEnviron; -function debuglog(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = 0; - debugs[set] = function() { - var msg = format.apply(null, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } - } - return debugs[set]; -} - -/** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ -/* legacy: obj, showHidden, depth, colors*/ -function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - _extend(ctx, opts); - } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); -} - -// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics -inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] -}; - -// Don't use 'blue' not visible on cmd.exe -inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' -}; - - -function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; - - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; - } -} - - -function stylizeNoColor(str, styleType) { - return str; -} - - -function arrayToHash(array) { - var hash = {}; - - array.forEach(function(val, idx) { - hash[val] = true; - }); - - return hash; -} - - -function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); - } - return ret; - } - - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; - } - - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); - - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); - } - - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); - } - - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } - } - - var base = '', array = false, braces = ['{', '}']; - - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; - } - - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; - } - - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); - } - - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); - } - - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); - } - - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; - } - - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); - } - } - - ctx.seen.push(value); - - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); - } - - ctx.seen.pop(); - - return reduceToSingleString(output, base, braces); -} - - -function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); - } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); -} - - -function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; -} - - -function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } - } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); - } - }); - return output; -} - - -function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); - } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); - } - } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; - } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); - } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); - } - } - - return name + ': ' + str; -} - - -function reduceToSingleString(output, base, braces) { - var length = output.reduce(function(prev, cur) { - if (cur.indexOf('\n') >= 0) ; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); - - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; - } - - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; -} - - -// NOTE: These type checking functions intentionally don't use `instanceof` -// because it is fragile and can be easily faked with `Object.create()`. -function isArray(ar) { - return Array.isArray(ar); -} - -function isBoolean(arg) { - return typeof arg === 'boolean'; -} - -function isNull(arg) { - return arg === null; -} - -function isNullOrUndefined(arg) { - return arg == null; -} - -function isNumber(arg) { - return typeof arg === 'number'; -} - -function isString(arg) { - return typeof arg === 'string'; -} - -function isSymbol(arg) { - return typeof arg === 'symbol'; -} - -function isUndefined(arg) { - return arg === void 0; -} - -function isRegExp(re) { - return isObject(re) && objectToString(re) === '[object RegExp]'; -} - -function isObject(arg) { - return typeof arg === 'object' && arg !== null; -} - -function isDate(d) { - return isObject(d) && objectToString(d) === '[object Date]'; -} - -function isError(e) { - return isObject(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); -} - -function isFunction(arg) { - return typeof arg === 'function'; -} - -function isPrimitive(arg) { - return arg === null || - typeof arg === 'boolean' || - typeof arg === 'number' || - typeof arg === 'string' || - typeof arg === 'symbol' || // ES6 symbol - typeof arg === 'undefined'; -} - -function isBuffer(maybeBuf) { - return isBuffer$1(maybeBuf); -} - -function objectToString(o) { - return Object.prototype.toString.call(o); -} - - -function pad(n) { - return n < 10 ? '0' + n.toString(10) : n.toString(10); -} - - -var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', - 'Oct', 'Nov', 'Dec']; - -// 26 Feb 16:19:34 -function timestamp() { - var d = new Date(); - var time = [pad(d.getHours()), - pad(d.getMinutes()), - pad(d.getSeconds())].join(':'); - return [d.getDate(), months[d.getMonth()], time].join(' '); -} - - -// log is just a thin wrapper to console.log that prepends a timestamp -function log() { - console.log('%s - %s', timestamp(), format.apply(null, arguments)); -} - -function _extend(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject(add)) return origin; - - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; -} -function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); -} - -var util = { - inherits: inherits$1, - _extend: _extend, - log: log, - isBuffer: isBuffer, - isPrimitive: isPrimitive, - isFunction: isFunction, - isError: isError, - isDate: isDate, - isObject: isObject, - isRegExp: isRegExp, - isUndefined: isUndefined, - isSymbol: isSymbol, - isString: isString, - isNumber: isNumber, - isNullOrUndefined: isNullOrUndefined, - isNull: isNull, - isBoolean: isBoolean, - isArray: isArray, - inspect: inspect, - deprecate: deprecate, - format: format, - debuglog: debuglog -}; - -function BufferList() { - this.head = null; - this.tail = null; - this.length = 0; -} - -BufferList.prototype.push = function (v) { - var entry = { data: v, next: null }; - if (this.length > 0) this.tail.next = entry;else this.head = entry; - this.tail = entry; - ++this.length; -}; - -BufferList.prototype.unshift = function (v) { - var entry = { data: v, next: this.head }; - if (this.length === 0) this.tail = entry; - this.head = entry; - ++this.length; -}; - -BufferList.prototype.shift = function () { - if (this.length === 0) return; - var ret = this.head.data; - if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; - --this.length; - return ret; -}; - -BufferList.prototype.clear = function () { - this.head = this.tail = null; - this.length = 0; -}; - -BufferList.prototype.join = function (s) { - if (this.length === 0) return ''; - var p = this.head; - var ret = '' + p.data; - while (p = p.next) { - ret += s + p.data; - }return ret; -}; - -BufferList.prototype.concat = function (n) { - if (this.length === 0) return Buffer.alloc(0); - if (this.length === 1) return this.head.data; - var ret = Buffer.allocUnsafe(n >>> 0); - var p = this.head; - var i = 0; - while (p) { - p.data.copy(ret, i); - i += p.data.length; - p = p.next; - } - return ret; -}; - -// Copyright Joyent, Inc. and other Node contributors. -var isBufferEncoding = Buffer.isEncoding - || function(encoding) { - switch (encoding && encoding.toLowerCase()) { - case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true; - default: return false; - } - }; - - -function assertEncoding(encoding) { - if (encoding && !isBufferEncoding(encoding)) { - throw new Error('Unknown encoding: ' + encoding); - } -} - -// StringDecoder provides an interface for efficiently splitting a series of -// buffers into a series of JS strings without breaking apart multi-byte -// characters. CESU-8 is handled as part of the UTF-8 encoding. -// -// @TODO Handling all encodings inside a single object makes it very difficult -// to reason about this code, so it should be split up in the future. -// @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code -// points as used by CESU-8. -function StringDecoder(encoding) { - this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, ''); - assertEncoding(encoding); - switch (this.encoding) { - case 'utf8': - // CESU-8 represents each of Surrogate Pair by 3-bytes - this.surrogateSize = 3; - break; - case 'ucs2': - case 'utf16le': - // UTF-16 represents each of Surrogate Pair by 2-bytes - this.surrogateSize = 2; - this.detectIncompleteChar = utf16DetectIncompleteChar; - break; - case 'base64': - // Base-64 stores 3 bytes in 4 chars, and pads the remainder. - this.surrogateSize = 3; - this.detectIncompleteChar = base64DetectIncompleteChar; - break; - default: - this.write = passThroughWrite; - return; - } - - // Enough space to store all bytes of a single character. UTF-8 needs 4 - // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate). - this.charBuffer = new Buffer(6); - // Number of bytes received for the current incomplete multi-byte character. - this.charReceived = 0; - // Number of bytes expected for the current incomplete multi-byte character. - this.charLength = 0; -} - -// write decodes the given buffer and returns it as JS string that is -// guaranteed to not contain any partial multi-byte characters. Any partial -// character found at the end of the buffer is buffered up, and will be -// returned when calling write again with the remaining bytes. -// -// Note: Converting a Buffer containing an orphan surrogate to a String -// currently works, but converting a String to a Buffer (via `new Buffer`, or -// Buffer#write) will replace incomplete surrogates with the unicode -// replacement character. See https://codereview.chromium.org/121173009/ . -StringDecoder.prototype.write = function(buffer) { - var charStr = ''; - // if our last write ended with an incomplete multibyte character - while (this.charLength) { - // determine how many remaining bytes this buffer has to offer for this char - var available = (buffer.length >= this.charLength - this.charReceived) ? - this.charLength - this.charReceived : - buffer.length; - - // add the new bytes to the char buffer - buffer.copy(this.charBuffer, this.charReceived, 0, available); - this.charReceived += available; - - if (this.charReceived < this.charLength) { - // still not enough chars in this buffer? wait for more ... - return ''; - } - - // remove bytes belonging to the current character from the buffer - buffer = buffer.slice(available, buffer.length); - - // get the character that was split - charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding); - - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - var charCode = charStr.charCodeAt(charStr.length - 1); - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - this.charLength += this.surrogateSize; - charStr = ''; - continue; - } - this.charReceived = this.charLength = 0; - - // if there are no more bytes in this buffer, just emit our char - if (buffer.length === 0) { - return charStr; - } - break; - } - - // determine and set charLength / charReceived - this.detectIncompleteChar(buffer); - - var end = buffer.length; - if (this.charLength) { - // buffer the incomplete character bytes we got - buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end); - end -= this.charReceived; - } - - charStr += buffer.toString(this.encoding, 0, end); - - var end = charStr.length - 1; - var charCode = charStr.charCodeAt(end); - // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character - if (charCode >= 0xD800 && charCode <= 0xDBFF) { - var size = this.surrogateSize; - this.charLength += size; - this.charReceived += size; - this.charBuffer.copy(this.charBuffer, size, 0, size); - buffer.copy(this.charBuffer, 0, 0, size); - return charStr.substring(0, end); - } - - // or just emit the charStr - return charStr; -}; - -// detectIncompleteChar determines if there is an incomplete UTF-8 character at -// the end of the given buffer. If so, it sets this.charLength to the byte -// length that character, and sets this.charReceived to the number of bytes -// that are available for this character. -StringDecoder.prototype.detectIncompleteChar = function(buffer) { - // determine how many bytes we have to check at the end of this buffer - var i = (buffer.length >= 3) ? 3 : buffer.length; - - // Figure out if one of the last i bytes of our buffer announces an - // incomplete char. - for (; i > 0; i--) { - var c = buffer[buffer.length - i]; - - // See http://en.wikipedia.org/wiki/UTF-8#Description - - // 110XXXXX - if (i == 1 && c >> 5 == 0x06) { - this.charLength = 2; - break; - } - - // 1110XXXX - if (i <= 2 && c >> 4 == 0x0E) { - this.charLength = 3; - break; - } - - // 11110XXX - if (i <= 3 && c >> 3 == 0x1E) { - this.charLength = 4; - break; - } - } - this.charReceived = i; -}; - -StringDecoder.prototype.end = function(buffer) { - var res = ''; - if (buffer && buffer.length) - res = this.write(buffer); - - if (this.charReceived) { - var cr = this.charReceived; - var buf = this.charBuffer; - var enc = this.encoding; - res += buf.slice(0, cr).toString(enc); - } - - return res; -}; - -function passThroughWrite(buffer) { - return buffer.toString(this.encoding); -} - -function utf16DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 2; - this.charLength = this.charReceived ? 2 : 0; -} - -function base64DetectIncompleteChar(buffer) { - this.charReceived = buffer.length % 3; - this.charLength = this.charReceived ? 3 : 0; -} - -Readable.ReadableState = ReadableState; - -var debug = debuglog('stream'); -inherits$1(Readable, EventEmitter); - -function prependListener(emitter, event, fn) { - // Sadly this is not cacheable as some libraries bundle their own - // event emitter implementation with them. - if (typeof emitter.prependListener === 'function') { - return emitter.prependListener(event, fn); - } else { - // This is a hack to make sure that our error handler is attached before any - // userland ones. NEVER DO THIS. This is here only because this code needs - // to continue to work with older versions of Node.js that do not include - // the prependListener() method. The goal is to eventually remove this hack. - if (!emitter._events || !emitter._events[event]) - emitter.on(event, fn); - else if (Array.isArray(emitter._events[event])) - emitter._events[event].unshift(fn); - else - emitter._events[event] = [fn, emitter._events[event]]; - } -} -function listenerCount (emitter, type) { - return emitter.listeners(type).length; -} -function ReadableState(options, stream) { - - options = options || {}; - - // object stream flag. Used to make read(n) ignore n and to - // make all the buffer merging and length checks go away - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; - - // the point at which it stops calling _read() to fill the buffer - // Note: 0 is a valid value, means "don't call _read preemptively ever" - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - // A linked list is used to store data chunks instead of an array because the - // linked list can remove elements from the beginning faster than - // array.shift() - this.buffer = new BufferList(); - this.length = 0; - this.pipes = null; - this.pipesCount = 0; - this.flowing = null; - this.ended = false; - this.endEmitted = false; - this.reading = false; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // whenever we return null, then we set a flag to say - // that we're awaiting a 'readable' event emission. - this.needReadable = false; - this.emittedReadable = false; - this.readableListening = false; - this.resumeScheduled = false; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // when piping, we only care about 'readable' events that happen - // after read()ing all the bytes and not getting any pushback. - this.ranOut = false; - - // the number of writers that are awaiting a drain event in .pipe()s - this.awaitDrain = 0; - - // if true, a maybeReadMore has been scheduled - this.readingMore = false; - - this.decoder = null; - this.encoding = null; - if (options.encoding) { - this.decoder = new StringDecoder(options.encoding); - this.encoding = options.encoding; - } -} -function Readable(options) { - - if (!(this instanceof Readable)) return new Readable(options); - - this._readableState = new ReadableState(options, this); - - // legacy - this.readable = true; - - if (options && typeof options.read === 'function') this._read = options.read; - - EventEmitter.call(this); -} - -// Manually shove something into the read() buffer. -// This returns true if the highWaterMark has not been hit yet, -// similar to how Writable.write() returns true if you should -// write() some more. -Readable.prototype.push = function (chunk, encoding) { - var state = this._readableState; - - if (!state.objectMode && typeof chunk === 'string') { - encoding = encoding || state.defaultEncoding; - if (encoding !== state.encoding) { - chunk = Buffer.from(chunk, encoding); - encoding = ''; - } - } - - return readableAddChunk(this, state, chunk, encoding, false); -}; - -// Unshift should *always* be something directly out of read() -Readable.prototype.unshift = function (chunk) { - var state = this._readableState; - return readableAddChunk(this, state, chunk, '', true); -}; - -Readable.prototype.isPaused = function () { - return this._readableState.flowing === false; -}; - -function readableAddChunk(stream, state, chunk, encoding, addToFront) { - var er = chunkInvalid(state, chunk); - if (er) { - stream.emit('error', er); - } else if (chunk === null) { - state.reading = false; - onEofChunk(stream, state); - } else if (state.objectMode || chunk && chunk.length > 0) { - if (state.ended && !addToFront) { - var e = new Error('stream.push() after EOF'); - stream.emit('error', e); - } else if (state.endEmitted && addToFront) { - var _e = new Error('stream.unshift() after end event'); - stream.emit('error', _e); - } else { - var skipAdd; - if (state.decoder && !addToFront && !encoding) { - chunk = state.decoder.write(chunk); - skipAdd = !state.objectMode && chunk.length === 0; - } - - if (!addToFront) state.reading = false; - - // Don't add to the buffer if we've decoded to an empty string chunk and - // we're not in object mode - if (!skipAdd) { - // if we want the data now, just emit it. - if (state.flowing && state.length === 0 && !state.sync) { - stream.emit('data', chunk); - stream.read(0); - } else { - // update the buffer info. - state.length += state.objectMode ? 1 : chunk.length; - if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); - - if (state.needReadable) emitReadable(stream); - } - } - - maybeReadMore(stream, state); - } - } else if (!addToFront) { - state.reading = false; - } - - return needMoreData(state); -} - -// if it's past the high water mark, we can push in some more. -// Also, if we have no data yet, we can stand some -// more bytes. This is to work around cases where hwm=0, -// such as the repl. Also, if the push() triggered a -// readable event, and the user called read(largeNumber) such that -// needReadable was set, then we ought to push more, so that another -// 'readable' event will be triggered. -function needMoreData(state) { - return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); -} - -// backwards compatibility. -Readable.prototype.setEncoding = function (enc) { - this._readableState.decoder = new StringDecoder(enc); - this._readableState.encoding = enc; - return this; -}; - -// Don't raise the hwm > 8MB -var MAX_HWM = 0x800000; -function computeNewHighWaterMark(n) { - if (n >= MAX_HWM) { - n = MAX_HWM; - } else { - // Get the next highest power of 2 to prevent increasing hwm excessively in - // tiny amounts - n--; - n |= n >>> 1; - n |= n >>> 2; - n |= n >>> 4; - n |= n >>> 8; - n |= n >>> 16; - n++; - } - return n; -} - -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function howMuchToRead(n, state) { - if (n <= 0 || state.length === 0 && state.ended) return 0; - if (state.objectMode) return 1; - if (n !== n) { - // Only flow one buffer at a time - if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; - } - // If we're asking for more than the current hwm, then raise the hwm. - if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); - if (n <= state.length) return n; - // Don't have enough - if (!state.ended) { - state.needReadable = true; - return 0; - } - return state.length; -} - -// you can override either this method, or the async _read(n) below. -Readable.prototype.read = function (n) { - debug('read', n); - n = parseInt(n, 10); - var state = this._readableState; - var nOrig = n; - - if (n !== 0) state.emittedReadable = false; - - // if we're doing read(0) to trigger a readable event, but we - // already have a bunch of data in the buffer, then just trigger - // the 'readable' event and move on. - if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { - debug('read: emitReadable', state.length, state.ended); - if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); - return null; - } - - n = howMuchToRead(n, state); - - // if we've ended, and we're now clear, then finish it up. - if (n === 0 && state.ended) { - if (state.length === 0) endReadable(this); - return null; - } - - // All the actual chunk generation logic needs to be - // *below* the call to _read. The reason is that in certain - // synthetic stream cases, such as passthrough streams, _read - // may be a completely synchronous operation which may change - // the state of the read buffer, providing enough data when - // before there was *not* enough. - // - // So, the steps are: - // 1. Figure out what the state of things will be after we do - // a read from the buffer. - // - // 2. If that resulting state will trigger a _read, then call _read. - // Note that this may be asynchronous, or synchronous. Yes, it is - // deeply ugly to write APIs this way, but that still doesn't mean - // that the Readable class should behave improperly, as streams are - // designed to be sync/async agnostic. - // Take note if the _read call is sync or async (ie, if the read call - // has returned yet), so that we know whether or not it's safe to emit - // 'readable' etc. - // - // 3. Actually pull the requested chunks out of the buffer and return. - - // if we need a readable event, then we need to do some reading. - var doRead = state.needReadable; - debug('need readable', doRead); - - // if we currently have less than the highWaterMark, then also read some - if (state.length === 0 || state.length - n < state.highWaterMark) { - doRead = true; - debug('length less than watermark', doRead); - } - - // however, if we've ended, then there's no point, and if we're already - // reading, then it's unnecessary. - if (state.ended || state.reading) { - doRead = false; - debug('reading or ended', doRead); - } else if (doRead) { - debug('do read'); - state.reading = true; - state.sync = true; - // if the length is currently zero, then we *need* a readable event. - if (state.length === 0) state.needReadable = true; - // call internal read method - this._read(state.highWaterMark); - state.sync = false; - // If _read pushed data synchronously, then `reading` will be false, - // and we need to re-evaluate how much data we can return to the user. - if (!state.reading) n = howMuchToRead(nOrig, state); - } - - var ret; - if (n > 0) ret = fromList(n, state);else ret = null; - - if (ret === null) { - state.needReadable = true; - n = 0; - } else { - state.length -= n; - } - - if (state.length === 0) { - // If we have nothing in the buffer, then we want to know - // as soon as we *do* get something into the buffer. - if (!state.ended) state.needReadable = true; - - // If we tried to read() past the EOF, then emit end on the next tick. - if (nOrig !== n && state.ended) endReadable(this); - } - - if (ret !== null) this.emit('data', ret); - - return ret; -}; - -function chunkInvalid(state, chunk) { - var er = null; - if (!isBuffer$1(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - return er; -} - -function onEofChunk(stream, state) { - if (state.ended) return; - if (state.decoder) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) { - state.buffer.push(chunk); - state.length += state.objectMode ? 1 : chunk.length; - } - } - state.ended = true; - - // emit 'readable' now to make sure it gets picked up. - emitReadable(stream); -} - -// Don't emit readable right away in sync mode, because this can trigger -// another read() call => stack overflow. This way, it might trigger -// a nextTick recursion warning, but that's not so bad. -function emitReadable(stream) { - var state = stream._readableState; - state.needReadable = false; - if (!state.emittedReadable) { - debug('emitReadable', state.flowing); - state.emittedReadable = true; - if (state.sync) nextTick(emitReadable_, stream);else emitReadable_(stream); - } -} - -function emitReadable_(stream) { - debug('emit readable'); - stream.emit('readable'); - flow(stream); -} - -// at this point, the user has presumably seen the 'readable' event, -// and called read() to consume some data. that may have triggered -// in turn another _read(n) call, in which case reading = true if -// it's in progress. -// However, if we're not ended, or reading, and the length < hwm, -// then go ahead and try to read some more preemptively. -function maybeReadMore(stream, state) { - if (!state.readingMore) { - state.readingMore = true; - nextTick(maybeReadMore_, stream, state); - } -} - -function maybeReadMore_(stream, state) { - var len = state.length; - while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { - debug('maybeReadMore read 0'); - stream.read(0); - if (len === state.length) - // didn't get any data, stop spinning. - break;else len = state.length; - } - state.readingMore = false; -} - -// abstract method. to be overridden in specific implementation classes. -// call cb(er, data) where data is <= n in length. -// for virtual (non-string, non-buffer) streams, "length" is somewhat -// arbitrary, and perhaps not very meaningful. -Readable.prototype._read = function (n) { - this.emit('error', new Error('not implemented')); -}; - -Readable.prototype.pipe = function (dest, pipeOpts) { - var src = this; - var state = this._readableState; - - switch (state.pipesCount) { - case 0: - state.pipes = dest; - break; - case 1: - state.pipes = [state.pipes, dest]; - break; - default: - state.pipes.push(dest); - break; - } - state.pipesCount += 1; - debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - - var doEnd = (!pipeOpts || pipeOpts.end !== false); - - var endFn = doEnd ? onend : cleanup; - if (state.endEmitted) nextTick(endFn);else src.once('end', endFn); - - dest.on('unpipe', onunpipe); - function onunpipe(readable) { - debug('onunpipe'); - if (readable === src) { - cleanup(); - } - } - - function onend() { - debug('onend'); - dest.end(); - } - - // when the dest drains, it reduces the awaitDrain counter - // on the source. This would be more elegant with a .once() - // handler in flow(), but adding and removing repeatedly is - // too slow. - var ondrain = pipeOnDrain(src); - dest.on('drain', ondrain); - - var cleanedUp = false; - function cleanup() { - debug('cleanup'); - // cleanup event handlers once the pipe is broken - dest.removeListener('close', onclose); - dest.removeListener('finish', onfinish); - dest.removeListener('drain', ondrain); - dest.removeListener('error', onerror); - dest.removeListener('unpipe', onunpipe); - src.removeListener('end', onend); - src.removeListener('end', cleanup); - src.removeListener('data', ondata); - - cleanedUp = true; - - // if the reader is waiting for a drain event from this - // specific writer, then it would cause it to never start - // flowing again. - // So, if this is awaiting a drain, then we just call it now. - // If we don't know, then assume that we are waiting for one. - if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); - } - - // If the user pushes more data while we're writing to dest then we'll end up - // in ondata again. However, we only want to increase awaitDrain once because - // dest will only emit one 'drain' event for the multiple writes. - // => Introduce a guard on increasing awaitDrain. - var increasedAwaitDrain = false; - src.on('data', ondata); - function ondata(chunk) { - debug('ondata'); - increasedAwaitDrain = false; - var ret = dest.write(chunk); - if (false === ret && !increasedAwaitDrain) { - // If the user unpiped during `dest.write()`, it is possible - // to get stuck in a permanently paused state if that write - // also returned false. - // => Check whether `dest` is still a piping destination. - if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { - debug('false write response, pause', src._readableState.awaitDrain); - src._readableState.awaitDrain++; - increasedAwaitDrain = true; - } - src.pause(); - } - } - - // if the dest has an error, then stop piping into it. - // however, don't suppress the throwing behavior for this. - function onerror(er) { - debug('onerror', er); - unpipe(); - dest.removeListener('error', onerror); - if (listenerCount(dest, 'error') === 0) dest.emit('error', er); - } - - // Make sure our error handler is attached before userland ones. - prependListener(dest, 'error', onerror); - - // Both close and finish should trigger unpipe, but only once. - function onclose() { - dest.removeListener('finish', onfinish); - unpipe(); - } - dest.once('close', onclose); - function onfinish() { - debug('onfinish'); - dest.removeListener('close', onclose); - unpipe(); - } - dest.once('finish', onfinish); - - function unpipe() { - debug('unpipe'); - src.unpipe(dest); - } - - // tell the dest that it's being piped to - dest.emit('pipe', src); - - // start the flow if it hasn't been started already. - if (!state.flowing) { - debug('pipe resume'); - src.resume(); - } - - return dest; -}; - -function pipeOnDrain(src) { - return function () { - var state = src._readableState; - debug('pipeOnDrain', state.awaitDrain); - if (state.awaitDrain) state.awaitDrain--; - if (state.awaitDrain === 0 && src.listeners('data').length) { - state.flowing = true; - flow(src); - } - }; -} - -Readable.prototype.unpipe = function (dest) { - var state = this._readableState; - - // if we're not piping anywhere, then do nothing. - if (state.pipesCount === 0) return this; - - // just one destination. most common case. - if (state.pipesCount === 1) { - // passed in one, but it's not the right one. - if (dest && dest !== state.pipes) return this; - - if (!dest) dest = state.pipes; - - // got a match. - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - if (dest) dest.emit('unpipe', this); - return this; - } - - // slow case. multiple pipe destinations. - - if (!dest) { - // remove all. - var dests = state.pipes; - var len = state.pipesCount; - state.pipes = null; - state.pipesCount = 0; - state.flowing = false; - - for (var _i = 0; _i < len; _i++) { - dests[_i].emit('unpipe', this); - }return this; - } - - // try to find the right one. - var i = indexOf(state.pipes, dest); - if (i === -1) return this; - - state.pipes.splice(i, 1); - state.pipesCount -= 1; - if (state.pipesCount === 1) state.pipes = state.pipes[0]; - - dest.emit('unpipe', this); - - return this; -}; - -// set up data events if they are asked for -// Ensure readable listeners eventually get something -Readable.prototype.on = function (ev, fn) { - var res = EventEmitter.prototype.on.call(this, ev, fn); - - if (ev === 'data') { - // Start flowing on next tick if stream isn't explicitly paused - if (this._readableState.flowing !== false) this.resume(); - } else if (ev === 'readable') { - var state = this._readableState; - if (!state.endEmitted && !state.readableListening) { - state.readableListening = state.needReadable = true; - state.emittedReadable = false; - if (!state.reading) { - nextTick(nReadingNextTick, this); - } else if (state.length) { - emitReadable(this); - } - } - } - - return res; -}; -Readable.prototype.addListener = Readable.prototype.on; - -function nReadingNextTick(self) { - debug('readable nexttick read 0'); - self.read(0); -} - -// pause() and resume() are remnants of the legacy readable stream API -// If the user uses them, then switch into old mode. -Readable.prototype.resume = function () { - var state = this._readableState; - if (!state.flowing) { - debug('resume'); - state.flowing = true; - resume(this, state); - } - return this; -}; - -function resume(stream, state) { - if (!state.resumeScheduled) { - state.resumeScheduled = true; - nextTick(resume_, stream, state); - } -} - -function resume_(stream, state) { - if (!state.reading) { - debug('resume read 0'); - stream.read(0); - } - - state.resumeScheduled = false; - state.awaitDrain = 0; - stream.emit('resume'); - flow(stream); - if (state.flowing && !state.reading) stream.read(0); -} - -Readable.prototype.pause = function () { - debug('call pause flowing=%j', this._readableState.flowing); - if (false !== this._readableState.flowing) { - debug('pause'); - this._readableState.flowing = false; - this.emit('pause'); - } - return this; -}; - -function flow(stream) { - var state = stream._readableState; - debug('flow', state.flowing); - while (state.flowing && stream.read() !== null) {} -} - -// wrap an old-style stream as the async data source. -// This is *not* part of the readable stream interface. -// It is an ugly unfortunate mess of history. -Readable.prototype.wrap = function (stream) { - var state = this._readableState; - var paused = false; - - var self = this; - stream.on('end', function () { - debug('wrapped end'); - if (state.decoder && !state.ended) { - var chunk = state.decoder.end(); - if (chunk && chunk.length) self.push(chunk); - } - - self.push(null); - }); - - stream.on('data', function (chunk) { - debug('wrapped data'); - if (state.decoder) chunk = state.decoder.write(chunk); - - // don't skip over falsy values in objectMode - if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; - - var ret = self.push(chunk); - if (!ret) { - paused = true; - stream.pause(); - } - }); - - // proxy all the other methods. - // important when wrapping filters and duplexes. - for (var i in stream) { - if (this[i] === undefined && typeof stream[i] === 'function') { - this[i] = function (method) { - return function () { - return stream[method].apply(stream, arguments); - }; - }(i); - } - } - - // proxy certain important events. - var events = ['error', 'close', 'destroy', 'pause', 'resume']; - forEach(events, function (ev) { - stream.on(ev, self.emit.bind(self, ev)); - }); - - // when we try to consume some more bytes, simply unpause the - // underlying stream. - self._read = function (n) { - debug('wrapped _read', n); - if (paused) { - paused = false; - stream.resume(); - } - }; - - return self; -}; - -// exposed for testing purposes only. -Readable._fromList = fromList; - -// Pluck off n bytes from an array of buffers. -// Length is the combined lengths of all the buffers in the list. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromList(n, state) { - // nothing buffered - if (state.length === 0) return null; - - var ret; - if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { - // read it all, truncate the list - if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); - state.buffer.clear(); - } else { - // read part of list - ret = fromListPartial(n, state.buffer, state.decoder); - } - - return ret; -} - -// Extracts only enough buffered data to satisfy the amount requested. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function fromListPartial(n, list, hasStrings) { - var ret; - if (n < list.head.data.length) { - // slice is the same for buffers and strings - ret = list.head.data.slice(0, n); - list.head.data = list.head.data.slice(n); - } else if (n === list.head.data.length) { - // first chunk is a perfect match - ret = list.shift(); - } else { - // result spans more than one buffer - ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); - } - return ret; -} - -// Copies a specified amount of characters from the list of buffered data -// chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBufferString(n, list) { - var p = list.head; - var c = 1; - var ret = p.data; - n -= ret.length; - while (p = p.next) { - var str = p.data; - var nb = n > str.length ? str.length : n; - if (nb === str.length) ret += str;else ret += str.slice(0, n); - n -= nb; - if (n === 0) { - if (nb === str.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = str.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -// Copies a specified amount of bytes from the list of buffered data chunks. -// This function is designed to be inlinable, so please take care when making -// changes to the function body. -function copyFromBuffer(n, list) { - var ret = Buffer.allocUnsafe(n); - var p = list.head; - var c = 1; - p.data.copy(ret); - n -= p.data.length; - while (p = p.next) { - var buf = p.data; - var nb = n > buf.length ? buf.length : n; - buf.copy(ret, ret.length - n, 0, nb); - n -= nb; - if (n === 0) { - if (nb === buf.length) { - ++c; - if (p.next) list.head = p.next;else list.head = list.tail = null; - } else { - list.head = p; - p.data = buf.slice(nb); - } - break; - } - ++c; - } - list.length -= c; - return ret; -} - -function endReadable(stream) { - var state = stream._readableState; - - // If we get here before consuming all the bytes, then that is a - // bug in node. Should never happen. - if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); - - if (!state.endEmitted) { - state.ended = true; - nextTick(endReadableNT, state, stream); - } -} - -function endReadableNT(state, stream) { - // Check that we didn't get one last unshift. - if (!state.endEmitted && state.length === 0) { - state.endEmitted = true; - stream.readable = false; - stream.emit('end'); - } -} - -function forEach(xs, f) { - for (var i = 0, l = xs.length; i < l; i++) { - f(xs[i], i); - } -} - -function indexOf(xs, x) { - for (var i = 0, l = xs.length; i < l; i++) { - if (xs[i] === x) return i; - } - return -1; -} - -// A bit simpler than readable streams. -Writable.WritableState = WritableState; -inherits$1(Writable, EventEmitter); - -function nop() {} - -function WriteReq(chunk, encoding, cb) { - this.chunk = chunk; - this.encoding = encoding; - this.callback = cb; - this.next = null; -} - -function WritableState(options, stream) { - Object.defineProperty(this, 'buffer', { - get: deprecate(function () { - return this.getBuffer(); - }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') - }); - options = options || {}; - - // object stream flag to indicate whether or not this stream - // contains buffers or objects. - this.objectMode = !!options.objectMode; - - if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; - - // the point at which write() starts returning false - // Note: 0 is a valid value, means that we always return false if - // the entire buffer is not flushed immediately on write() - var hwm = options.highWaterMark; - var defaultHwm = this.objectMode ? 16 : 16 * 1024; - this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; - - // cast to ints. - this.highWaterMark = ~ ~this.highWaterMark; - - this.needDrain = false; - // at the start of calling end() - this.ending = false; - // when end() has been called, and returned - this.ended = false; - // when 'finish' is emitted - this.finished = false; - - // should we decode strings into buffers before passing to _write? - // this is here so that some node-core streams can optimize string - // handling at a lower level. - var noDecode = options.decodeStrings === false; - this.decodeStrings = !noDecode; - - // Crypto is kind of old and crusty. Historically, its default string - // encoding is 'binary' so we have to make this configurable. - // Everything else in the universe uses 'utf8', though. - this.defaultEncoding = options.defaultEncoding || 'utf8'; - - // not an actual buffer we keep track of, but a measurement - // of how much we're waiting to get pushed to some underlying - // socket or file. - this.length = 0; - - // a flag to see when we're in the middle of a write. - this.writing = false; - - // when true all writes will be buffered until .uncork() call - this.corked = 0; - - // a flag to be able to tell if the onwrite cb is called immediately, - // or on a later tick. We set this to true at first, because any - // actions that shouldn't happen until "later" should generally also - // not happen before the first write call. - this.sync = true; - - // a flag to know if we're processing previously buffered items, which - // may call the _write() callback in the same tick, so that we don't - // end up in an overlapped onwrite situation. - this.bufferProcessing = false; - - // the callback that's passed to _write(chunk,cb) - this.onwrite = function (er) { - onwrite(stream, er); - }; - - // the callback that the user supplies to write(chunk,encoding,cb) - this.writecb = null; - - // the amount that is being written when _write is called. - this.writelen = 0; - - this.bufferedRequest = null; - this.lastBufferedRequest = null; - - // number of pending user-supplied write callbacks - // this must be 0 before 'finish' can be emitted - this.pendingcb = 0; - - // emit prefinish if the only thing we're waiting for is _write cbs - // This is relevant for synchronous Transform streams - this.prefinished = false; - - // True if the error was already emitted and should not be thrown again - this.errorEmitted = false; - - // count buffered requests - this.bufferedRequestCount = 0; - - // allocate the first CorkedRequest, there is always - // one allocated and free to use, and we maintain at most two - this.corkedRequestsFree = new CorkedRequest(this); -} - -WritableState.prototype.getBuffer = function writableStateGetBuffer() { - var current = this.bufferedRequest; - var out = []; - while (current) { - out.push(current); - current = current.next; - } - return out; -}; -function Writable(options) { - - // Writable ctor is applied to Duplexes, though they're not - // instanceof Writable, they're instanceof Readable. - if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - - this._writableState = new WritableState(options, this); - - // legacy. - this.writable = true; - - if (options) { - if (typeof options.write === 'function') this._write = options.write; - - if (typeof options.writev === 'function') this._writev = options.writev; - } - - EventEmitter.call(this); -} - -// Otherwise people can pipe Writable streams, which is just wrong. -Writable.prototype.pipe = function () { - this.emit('error', new Error('Cannot pipe, not readable')); -}; - -function writeAfterEnd(stream, cb) { - var er = new Error('write after end'); - // TODO: defer error events consistently everywhere, not just the cb - stream.emit('error', er); - nextTick(cb, er); -} - -// If we get something that is not a buffer, string, null, or undefined, -// and we're not in objectMode, then that's an error. -// Otherwise stream chunks are all considered to be of length=1, and the -// watermarks determine how many objects to keep in the buffer, rather than -// how many bytes or characters. -function validChunk(stream, state, chunk, cb) { - var valid = true; - var er = false; - // Always throw error if a null is written - // if we are not in object mode then throw - // if it is not a buffer, string, or undefined. - if (chunk === null) { - er = new TypeError('May not write null values to stream'); - } else if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { - er = new TypeError('Invalid non-string/buffer chunk'); - } - if (er) { - stream.emit('error', er); - nextTick(cb, er); - valid = false; - } - return valid; -} - -Writable.prototype.write = function (chunk, encoding, cb) { - var state = this._writableState; - var ret = false; - - if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - - if (typeof cb !== 'function') cb = nop; - - if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { - state.pendingcb++; - ret = writeOrBuffer(this, state, chunk, encoding, cb); - } - - return ret; -}; - -Writable.prototype.cork = function () { - var state = this._writableState; - - state.corked++; -}; - -Writable.prototype.uncork = function () { - var state = this._writableState; - - if (state.corked) { - state.corked--; - - if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); - } -}; - -Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { - // node::ParseEncoding() requires lower case. - if (typeof encoding === 'string') encoding = encoding.toLowerCase(); - if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); - this._writableState.defaultEncoding = encoding; - return this; -}; - -function decodeChunk(state, chunk, encoding) { - if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { - chunk = Buffer.from(chunk, encoding); - } - return chunk; -} - -// if we're already writing something, then just put this -// in the queue, and wait our turn. Otherwise, call _write -// If we return false, then we need a drain event, so set that flag. -function writeOrBuffer(stream, state, chunk, encoding, cb) { - chunk = decodeChunk(state, chunk, encoding); - - if (Buffer.isBuffer(chunk)) encoding = 'buffer'; - var len = state.objectMode ? 1 : chunk.length; - - state.length += len; - - var ret = state.length < state.highWaterMark; - // we must ensure that previous needDrain will not be reset to false. - if (!ret) state.needDrain = true; - - if (state.writing || state.corked) { - var last = state.lastBufferedRequest; - state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); - if (last) { - last.next = state.lastBufferedRequest; - } else { - state.bufferedRequest = state.lastBufferedRequest; - } - state.bufferedRequestCount += 1; - } else { - doWrite(stream, state, false, len, chunk, encoding, cb); - } - - return ret; -} - -function doWrite(stream, state, writev, len, chunk, encoding, cb) { - state.writelen = len; - state.writecb = cb; - state.writing = true; - state.sync = true; - if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); - state.sync = false; -} - -function onwriteError(stream, state, sync, er, cb) { - --state.pendingcb; - if (sync) nextTick(cb, er);else cb(er); - - stream._writableState.errorEmitted = true; - stream.emit('error', er); -} - -function onwriteStateUpdate(state) { - state.writing = false; - state.writecb = null; - state.length -= state.writelen; - state.writelen = 0; -} - -function onwrite(stream, er) { - var state = stream._writableState; - var sync = state.sync; - var cb = state.writecb; - - onwriteStateUpdate(state); - - if (er) onwriteError(stream, state, sync, er, cb);else { - // Check if we're actually ready to finish, but don't emit yet - var finished = needFinish(state); - - if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { - clearBuffer(stream, state); - } - - if (sync) { - /**/ - nextTick(afterWrite, stream, state, finished, cb); - /**/ - } else { - afterWrite(stream, state, finished, cb); - } - } -} - -function afterWrite(stream, state, finished, cb) { - if (!finished) onwriteDrain(stream, state); - state.pendingcb--; - cb(); - finishMaybe(stream, state); -} - -// Must force callback to be called on nextTick, so that we don't -// emit 'drain' before the write() consumer gets the 'false' return -// value, and has a chance to attach a 'drain' listener. -function onwriteDrain(stream, state) { - if (state.length === 0 && state.needDrain) { - state.needDrain = false; - stream.emit('drain'); - } -} - -// if there's something in the buffer waiting, then process it -function clearBuffer(stream, state) { - state.bufferProcessing = true; - var entry = state.bufferedRequest; - - if (stream._writev && entry && entry.next) { - // Fast case, write everything using _writev() - var l = state.bufferedRequestCount; - var buffer = new Array(l); - var holder = state.corkedRequestsFree; - holder.entry = entry; - - var count = 0; - while (entry) { - buffer[count] = entry; - entry = entry.next; - count += 1; - } - - doWrite(stream, state, true, state.length, buffer, '', holder.finish); - - // doWrite is almost always async, defer these to save a bit of time - // as the hot path ends with doWrite - state.pendingcb++; - state.lastBufferedRequest = null; - if (holder.next) { - state.corkedRequestsFree = holder.next; - holder.next = null; - } else { - state.corkedRequestsFree = new CorkedRequest(state); - } - } else { - // Slow case, write chunks one-by-one - while (entry) { - var chunk = entry.chunk; - var encoding = entry.encoding; - var cb = entry.callback; - var len = state.objectMode ? 1 : chunk.length; - - doWrite(stream, state, false, len, chunk, encoding, cb); - entry = entry.next; - // if we didn't call the onwrite immediately, then - // it means that we need to wait until it does. - // also, that means that the chunk and cb are currently - // being processed, so move the buffer counter past them. - if (state.writing) { - break; - } - } - - if (entry === null) state.lastBufferedRequest = null; - } - - state.bufferedRequestCount = 0; - state.bufferedRequest = entry; - state.bufferProcessing = false; -} - -Writable.prototype._write = function (chunk, encoding, cb) { - cb(new Error('not implemented')); -}; - -Writable.prototype._writev = null; - -Writable.prototype.end = function (chunk, encoding, cb) { - var state = this._writableState; - - if (typeof chunk === 'function') { - cb = chunk; - chunk = null; - encoding = null; - } else if (typeof encoding === 'function') { - cb = encoding; - encoding = null; - } - - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - - // .end() fully uncorks - if (state.corked) { - state.corked = 1; - this.uncork(); - } - - // ignore unnecessary end() calls. - if (!state.ending && !state.finished) endWritable(this, state, cb); -}; - -function needFinish(state) { - return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; -} - -function prefinish(stream, state) { - if (!state.prefinished) { - state.prefinished = true; - stream.emit('prefinish'); - } -} - -function finishMaybe(stream, state) { - var need = needFinish(state); - if (need) { - if (state.pendingcb === 0) { - prefinish(stream, state); - state.finished = true; - stream.emit('finish'); - } else { - prefinish(stream, state); - } - } - return need; -} - -function endWritable(stream, state, cb) { - state.ending = true; - finishMaybe(stream, state); - if (cb) { - if (state.finished) nextTick(cb);else stream.once('finish', cb); - } - state.ended = true; - stream.writable = false; -} - -// It seems a linked list but it is not -// there will be only 2 of these for each stream -function CorkedRequest(state) { - var _this = this; - - this.next = null; - this.entry = null; - - this.finish = function (err) { - var entry = _this.entry; - _this.entry = null; - while (entry) { - var cb = entry.callback; - state.pendingcb--; - cb(err); - entry = entry.next; - } - if (state.corkedRequestsFree) { - state.corkedRequestsFree.next = _this; - } else { - state.corkedRequestsFree = _this; - } - }; -} - -inherits$1(Duplex, Readable); - -var keys = Object.keys(Writable.prototype); -for (var v = 0; v < keys.length; v++) { - var method = keys[v]; - if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; -} -function Duplex(options) { - if (!(this instanceof Duplex)) return new Duplex(options); - - Readable.call(this, options); - Writable.call(this, options); - - if (options && options.readable === false) this.readable = false; - - if (options && options.writable === false) this.writable = false; - - this.allowHalfOpen = true; - if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - - this.once('end', onend); -} - -// the no-half-open enforcer -function onend() { - // if we allow half-open state, or if the writable side ended, - // then we're ok. - if (this.allowHalfOpen || this._writableState.ended) return; - - // no more data can be written. - // But allow more writes to happen in this tick. - nextTick(onEndNT, this); -} - -function onEndNT(self) { - self.end(); -} - -// a transform stream is a readable/writable stream where you do -inherits$1(Transform, Duplex); - -function TransformState(stream) { - this.afterTransform = function (er, data) { - return afterTransform(stream, er, data); - }; - - this.needTransform = false; - this.transforming = false; - this.writecb = null; - this.writechunk = null; - this.writeencoding = null; -} - -function afterTransform(stream, er, data) { - var ts = stream._transformState; - ts.transforming = false; - - var cb = ts.writecb; - - if (!cb) return stream.emit('error', new Error('no writecb in Transform class')); - - ts.writechunk = null; - ts.writecb = null; - - if (data !== null && data !== undefined) stream.push(data); - - cb(er); - - var rs = stream._readableState; - rs.reading = false; - if (rs.needReadable || rs.length < rs.highWaterMark) { - stream._read(rs.highWaterMark); - } -} -function Transform(options) { - if (!(this instanceof Transform)) return new Transform(options); - - Duplex.call(this, options); - - this._transformState = new TransformState(this); - - // when the writable side finishes, then flush out anything remaining. - var stream = this; - - // start out asking for a readable event once data is transformed. - this._readableState.needReadable = true; - - // we have implemented the _read method, and done the other things - // that Readable wants before the first _read call, so unset the - // sync guard flag. - this._readableState.sync = false; - - if (options) { - if (typeof options.transform === 'function') this._transform = options.transform; - - if (typeof options.flush === 'function') this._flush = options.flush; - } - - this.once('prefinish', function () { - if (typeof this._flush === 'function') this._flush(function (er) { - done(stream, er); - });else done(stream); - }); -} - -Transform.prototype.push = function (chunk, encoding) { - this._transformState.needTransform = false; - return Duplex.prototype.push.call(this, chunk, encoding); -}; - -// This is the part where you do stuff! -// override this function in implementation classes. -// 'chunk' is an input chunk. -// -// Call `push(newChunk)` to pass along transformed output -// to the readable side. You may call 'push' zero or more times. -// -// Call `cb(err)` when you are done with this chunk. If you pass -// an error, then that'll put the hurt on the whole operation. If you -// never call cb(), then you'll never get another chunk. -Transform.prototype._transform = function (chunk, encoding, cb) { - throw new Error('Not implemented'); -}; - -Transform.prototype._write = function (chunk, encoding, cb) { - var ts = this._transformState; - ts.writecb = cb; - ts.writechunk = chunk; - ts.writeencoding = encoding; - if (!ts.transforming) { - var rs = this._readableState; - if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); - } -}; - -// Doesn't matter what the args are here. -// _transform does all the work. -// That we got here means that the readable side wants more data. -Transform.prototype._read = function (n) { - var ts = this._transformState; - - if (ts.writechunk !== null && ts.writecb && !ts.transforming) { - ts.transforming = true; - this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); - } else { - // mark that we need a transform, so that any data that comes in - // will get processed, now that we've asked for it. - ts.needTransform = true; - } -}; - -function done(stream, er) { - if (er) return stream.emit('error', er); - - // if there's nothing in the write buffer, then that means - // that nothing more will ever be provided - var ws = stream._writableState; - var ts = stream._transformState; - - if (ws.length) throw new Error('Calling transform done when ws.length != 0'); - - if (ts.transforming) throw new Error('Calling transform done when still transforming'); - - return stream.push(null); -} - -inherits$1(PassThrough, Transform); -function PassThrough(options) { - if (!(this instanceof PassThrough)) return new PassThrough(options); - - Transform.call(this, options); -} - -PassThrough.prototype._transform = function (chunk, encoding, cb) { - cb(null, chunk); -}; - -inherits$1(Stream, EventEmitter); -Stream.Readable = Readable; -Stream.Writable = Writable; -Stream.Duplex = Duplex; -Stream.Transform = Transform; -Stream.PassThrough = PassThrough; - -// Backwards-compat with node 0.4.x -Stream.Stream = Stream; - -// old-style streams. Note that the pipe method (the only relevant -// part of this class) is overridden in the Readable class. - -function Stream() { - EventEmitter.call(this); -} - -Stream.prototype.pipe = function(dest, options) { - var source = this; - - function ondata(chunk) { - if (dest.writable) { - if (false === dest.write(chunk) && source.pause) { - source.pause(); - } - } - } - - source.on('data', ondata); - - function ondrain() { - if (source.readable && source.resume) { - source.resume(); - } - } - - dest.on('drain', ondrain); - - // If the 'end' option is not supplied, dest.end() will be called when - // source gets the 'end' or 'close' events. Only dest.end() once. - if (!dest._isStdio && (!options || options.end !== false)) { - source.on('end', onend); - source.on('close', onclose); - } - - var didOnEnd = false; - function onend() { - if (didOnEnd) return; - didOnEnd = true; - - dest.end(); - } - - - function onclose() { - if (didOnEnd) return; - didOnEnd = true; - - if (typeof dest.destroy === 'function') dest.destroy(); - } - - // don't leave dangling pipes when there are errors. - function onerror(er) { - cleanup(); - if (EventEmitter.listenerCount(this, 'error') === 0) { - throw er; // Unhandled stream error in pipe. - } - } - - source.on('error', onerror); - dest.on('error', onerror); - - // remove all the event listeners that were added. - function cleanup() { - source.removeListener('data', ondata); - dest.removeListener('drain', ondrain); - - source.removeListener('end', onend); - source.removeListener('close', onclose); - - source.removeListener('error', onerror); - dest.removeListener('error', onerror); - - source.removeListener('end', cleanup); - source.removeListener('close', cleanup); - - dest.removeListener('close', cleanup); - } - - source.on('end', cleanup); - source.on('close', cleanup); - - dest.on('close', cleanup); - - dest.emit('pipe', source); - - // Allow for unix-like usage: A.pipe(B).pipe(C) - return dest; -}; +var stream__default = /*#__PURE__*/_interopDefaultLegacy(stream); +var util__default = /*#__PURE__*/_interopDefaultLegacy(util); const Transformer = function(options = {}, handler){ this.options = options; @@ -5053,7 +23,7 @@ const Transformer = function(options = {}, handler){ options.params = null; } this.handler = handler; - Stream.Transform.call(this, this.options); + stream__default["default"].Transform.call(this, this.options); this.state = { running: 0, started: 0, @@ -5062,7 +32,7 @@ const Transformer = function(options = {}, handler){ return this; }; -util.inherits(Transformer, Stream.Transform); +util__default["default"].inherits(Transformer, stream__default["default"].Transform); Transformer.prototype._transform = function(chunk, encoding, cb){ this.state.started++; diff --git a/packages/stream-transform/rollup.config.js b/packages/stream-transform/rollup.config.js index 319624024..2fde673ec 100644 --- a/packages/stream-transform/rollup.config.js +++ b/packages/stream-transform/rollup.config.js @@ -14,10 +14,6 @@ export default [{ }, input: 'lib/index.js', output: [ - { - file: `dist/cjs/index.cjs`, - format: 'cjs' - }, { file: `dist/esm/index.js`, format: 'esm' @@ -36,6 +32,17 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/index.js', + output: [ + { + file: `dist/cjs/index.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }, { onwarn: function(warning, rollupWarn) { if (warning.code === 'CIRCULAR_DEPENDENCY') return; @@ -43,10 +50,6 @@ export default [{ }, input: 'lib/sync.js', output: [ - { - file: `dist/cjs/sync.cjs`, - format: 'cjs' - }, { file: `dist/esm/sync.js`, format: 'esm' @@ -65,4 +68,15 @@ export default [{ plugins: [eslint({ fix: true, }), globals(), builtins(), nodeResolve()], +}, { + input: 'lib/sync.js', + output: [ + { + file: `dist/cjs/sync.cjs`, + format: 'cjs' + }, + ], + plugins: [eslint({ + fix: true, + }), nodeResolve()], }];