Correct rustc and clippy warnings

Author: Rémi Lauzier

benches/hashmap.rs

@@ -9,7 +9,6 @@ extern crate rand;
 extern crate test;
 
 use rand::{rngs::SmallRng, Rng, SeedableRng};
-use std::iter::FromIterator;
 use test::Bencher;
 
 use im::hashmap::HashMap;
@@ -41,7 +40,7 @@ fn reorder<A: Copy>(vec: &[A]) -> Vec<A> {
 fn hashmap_lookup_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
     let order = reorder(&keys);
-    let m: HashMap<i64, i64> = HashMap::from_iter(keys.into_iter().map(|i| (i, 1)));
+    let m: HashMap<i64, i64> = keys.into_iter().map(|i| (i, 1)).collect::<HashMap<_, _>>();
     b.iter(|| {
         for i in &order {
             let _ = m.get(i);
@@ -122,7 +121,7 @@ fn hashmap_insert_mut_10000(b: &mut Bencher) {
 fn hashmap_remove_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
     let order = reorder(&keys);
-    let map: HashMap<i64, i64> = HashMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: HashMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<HashMap<_, _>>();
     b.iter(|| {
         let mut m = map.clone();
         for i in &order {
@@ -149,7 +148,7 @@ fn hashmap_remove_1000(b: &mut Bencher) {
 fn hashmap_remove_mut_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
     let order = reorder(&keys);
-    let map: HashMap<i64, i64> = HashMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: HashMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<HashMap<_, _>>();
     b.iter(|| {
         let mut m = map.clone();
         for i in &order {
@@ -176,7 +175,7 @@ fn hashmap_remove_mut_1000(b: &mut Bencher) {
 fn hashmap_insert_once_n(size: usize, b: &mut Bencher) {
     let mut keys = random_keys(size + 1);
     let key = keys.pop().unwrap();
-    let map: HashMap<i64, i64> = HashMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: HashMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<HashMap<_, _>>();
     b.iter(|| map.update(key, key))
 }
 
@@ -203,7 +202,7 @@ fn hashmap_insert_once_10000(b: &mut Bencher) {
 fn hashmap_remove_once_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size + 1);
     let key = keys[0];
-    let map: HashMap<i64, i64> = HashMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: HashMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<HashMap<_, _>>();
     b.iter(|| map.without(&key))
 }
 
@@ -230,7 +229,7 @@ fn hashmap_remove_once_10000(b: &mut Bencher) {
 fn hashmap_lookup_once_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size + 1);
     let key = keys[0];
-    let map: HashMap<i64, i64> = HashMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: HashMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<HashMap<_, _>>();
     b.iter(|| map.get(&key))
 }
 

benches/native.rs

@@ -10,7 +10,6 @@ extern crate test;
 
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 use std::collections::{BTreeMap, HashMap, VecDeque};
-use std::iter::FromIterator;
 use test::Bencher;
 
 fn random_keys(size: usize) -> Vec<i64> {
@@ -165,7 +164,7 @@ fn vecdeque_push_back_mut_100000(b: &mut Bencher) {
 }
 
 fn vecdeque_pop_front_mut(b: &mut Bencher, count: usize) {
-    let l = VecDeque::<i32>::from_iter(0..count as i32);
+    let l = (0..count as i32).collect::<VecDeque<i32>>();
     b.iter(|| {
         let mut p = l.clone();
         for _ in 0..count {
@@ -195,7 +194,7 @@ fn vecdeque_pop_front_mut_100000(b: &mut Bencher) {
 }
 
 fn vecdeque_pop_back_mut(b: &mut Bencher, count: usize) {
-    let l = VecDeque::<i32>::from_iter(0..count as i32);
+    let l = (0..count as i32).collect::<VecDeque<i32>>();
     b.iter(|| {
         let mut p = l.clone();
         for _ in 0..count {
@@ -225,7 +224,7 @@ fn vecdeque_pop_back_mut_100000(b: &mut Bencher) {
 }
 
 fn vecdeque_split(b: &mut Bencher, count: usize) {
-    let vec = VecDeque::<i32>::from_iter(0..count as i32);
+    let vec = (0..count as i32).collect::<VecDeque<i32>>();
     b.iter(|| {
         let mut left = vec.clone();
         let _right = left.split_off(count / 2);
@@ -254,8 +253,8 @@ fn vecdeque_split_100000(b: &mut Bencher) {
 
 fn vecdeque_append(b: &mut Bencher, count: usize) {
     let count = count as i32;
-    let vec1 = VecDeque::<i32>::from_iter(0..count / 2);
-    let vec2 = VecDeque::<i32>::from_iter(count / 2..count);
+    let vec1 = (0..count / 2).collect::<VecDeque<i32>>();
+    let vec2 = (count / 2..count).collect::<VecDeque<i32>>();
     b.iter(|| {
         let mut vec = vec1.clone();
         vec.append(&mut vec2.clone());
@@ -288,7 +287,7 @@ fn vecdeque_append_100000(b: &mut Bencher) {
 }
 
 fn vec_split(b: &mut Bencher, count: usize) {
-    let vec = Vec::<i32>::from_iter(0..count as i32);
+    let vec = (0..count as i32).collect::<Vec<i32>>();
     b.iter(|| {
         let _left = vec[..count / 2].to_owned();
         let _right = vec[count / 2..].to_owned();
@@ -317,8 +316,8 @@ fn vec_split_100000(b: &mut Bencher) {
 
 fn vec_append(b: &mut Bencher, count: usize) {
     let count = count as i32;
-    let vec1 = Vec::<i32>::from_iter(0..count / 2);
-    let vec2 = Vec::<i32>::from_iter(count / 2..count);
+    let vec1 = (0..count / 2).collect::<Vec<i32>>();
+    let vec2 = (count / 2..count).collect::<Vec<i32>>();
     b.iter(|| {
         let mut vec = vec1.clone();
         vec.append(&mut vec2.clone());
@@ -380,7 +379,7 @@ fn vec_push_back_mut_100000(b: &mut Bencher) {
 }
 
 fn vec_pop_back_mut(b: &mut Bencher, count: usize) {
-    let l = Vec::<i32>::from_iter(0..count as i32);
+    let l = (0..count as i32).collect::<Vec<i32>>();
     b.iter(|| {
         let mut p = l.clone();
         for _ in 0..count {

benches/ordmap.rs

@@ -10,7 +10,6 @@ extern crate test;
 
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 use std::collections::BTreeSet;
-use std::iter::FromIterator;
 use test::Bencher;
 
 use im::ordmap::OrdMap;
@@ -40,7 +39,7 @@ fn reorder<A: Copy>(vec: &[A]) -> Vec<A> {
 fn ordmap_lookup_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
     let order = reorder(&keys);
-    let m: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, 1)));
+    let m: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, 1)).collect::<OrdMap<_, _>>();
     b.iter(|| {
         for i in &order {
             let _ = m.get(i);
@@ -158,7 +157,7 @@ fn ordmap_insert_mut_pooled_10000(b: &mut Bencher) {
 fn ordmap_remove_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
     let order = reorder(&keys);
-    let map: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<OrdMap<_, _>>();
     b.iter(|| {
         let mut m = map.clone();
         for i in &order {
@@ -185,7 +184,7 @@ fn ordmap_remove_1000(b: &mut Bencher) {
 fn ordmap_remove_mut_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
     let order = reorder(&keys);
-    let map: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<OrdMap<_, _>>();
     b.iter(|| {
         let mut m = map.clone();
         for i in &order {
@@ -211,7 +210,7 @@ fn ordmap_remove_mut_1000(b: &mut Bencher) {
 
 #[bench]
 fn ordmap_remove_min_1000(b: &mut Bencher) {
-    let map: OrdMap<i64, i64> = OrdMap::from_iter((0..1000).map(|i| (i, i)));
+    let map: OrdMap<i64, i64> = (0..1000).map(|i| (i, i)).collect::<OrdMap<_, _>>();
     b.iter(|| {
         let mut m = map.clone();
         assert!(!m.is_empty());
@@ -224,7 +223,7 @@ fn ordmap_remove_min_1000(b: &mut Bencher) {
 
 #[bench]
 fn ordmap_remove_max_1000(b: &mut Bencher) {
-    let map: OrdMap<i64, i64> = OrdMap::from_iter((0..1000).map(|i| (i, i)));
+    let map: OrdMap<i64, i64> = (0..1000).map(|i| (i, i)).collect::<OrdMap<_, _>>();
     b.iter(|| {
         let mut m = map.clone();
         assert!(!m.is_empty());
@@ -238,7 +237,7 @@ fn ordmap_remove_max_1000(b: &mut Bencher) {
 fn ordmap_insert_once_n(size: usize, b: &mut Bencher) {
     let mut keys = random_keys(size + 1);
     let key = keys.pop().unwrap();
-    let map: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<OrdMap<_, _>>();
     b.iter(|| map.update(key, key))
 }
 
@@ -265,7 +264,7 @@ fn ordmap_insert_once_10000(b: &mut Bencher) {
 fn ordmap_remove_once_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size + 1);
     let key = keys[0];
-    let map: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<OrdMap<_, _>>();
     b.iter(|| map.without(&key))
 }
 
@@ -292,7 +291,7 @@ fn ordmap_remove_once_10000(b: &mut Bencher) {
 fn ordmap_lookup_once_n(size: usize, b: &mut Bencher) {
     let keys = random_keys(size + 1);
     let key = keys[0];
-    let map: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, i)));
+    let map: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, i)).collect::<OrdMap<_, _>>();
     b.iter(|| map.get(&key))
 }
 
@@ -318,7 +317,7 @@ fn ordmap_lookup_once_10000(b: &mut Bencher) {
 
 fn ordmap_iter(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
-    let m: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, 1)));
+    let m: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, 1)).collect::<OrdMap<_, _>>();
     b.iter(|| for _ in m.iter() {})
 }
 
@@ -344,7 +343,7 @@ fn ordmap_iter_10000(b: &mut Bencher) {
 
 fn ordmap_range_iter(size: usize, b: &mut Bencher) {
     let keys = random_keys(size);
-    let m: OrdMap<i64, i64> = OrdMap::from_iter(keys.into_iter().map(|i| (i, 1)));
+    let m: OrdMap<i64, i64> = keys.into_iter().map(|i| (i, 1)).collect::<OrdMap<_, _>>();
     b.iter(|| for _ in m.range(..) {})
 }
 

benches/vector.rs

@@ -11,7 +11,6 @@ extern crate test;
 
 use rand::distributions::{Distribution, Standard};
 use rand::Rng;
-use std::iter::FromIterator;
 use test::Bencher;
 
 use im::vector::Vector;
@@ -83,7 +82,7 @@ fn vector_push_back_mut_100000(b: &mut Bencher) {
 }
 
 fn vector_pop_front_mut(b: &mut Bencher, count: usize) {
-    let l = Vector::<i32>::from_iter(0..count as i32);
+    let l = (0..count as i32).collect::<Vector<i32>>();
     b.iter(|| {
         let mut p = l.clone();
         for _ in 0..count {
@@ -113,7 +112,7 @@ fn vector_pop_front_mut_100000(b: &mut Bencher) {
 }
 
 fn vector_pop_back_mut(b: &mut Bencher, count: usize) {
-    let l = Vector::<i32>::from_iter(0..count as i32);
+    let l = (0..count as i32).collect::<Vector<i32>>();
     b.iter(|| {
         let mut p = l.clone();
         for _ in 0..count {
@@ -143,7 +142,7 @@ fn vector_pop_back_mut_100000(b: &mut Bencher) {
 }
 
 fn vector_split(b: &mut Bencher, count: usize) {
-    let vec = Vector::<i32>::from_iter(0..count as i32);
+    let vec = (0..count as i32).collect::<Vector<i32>>();
     b.iter(|| vec.clone().split_off(count / 2))
 }
 
@@ -169,8 +168,8 @@ fn vector_split_100000(b: &mut Bencher) {
 
 fn vector_append(b: &mut Bencher, count: usize) {
     let count = count as i32;
-    let vec1 = Vector::<i32>::from_iter(0..count / 2);
-    let vec2 = Vector::<i32>::from_iter(count / 2..count);
+    let vec1 = (0..count / 2).collect::<Vector<i32>>();
+    let vec2 = (count / 2..count).collect::<Vector<i32>>();
     b.iter(|| {
         let mut vec = vec1.clone();
         vec.append(vec2.clone());

proptest-regressions/ord/map.txt

@@ -5,3 +5,4 @@
 # It is recommended to check this file in to source control so that
 # everyone who runs the test benefits from these saved cases.
 xs 888006417 2608449019 3789353629 478040202 # shrinks to ref m = {0: 0}
+cc 1cc795607ade8b03fded509b229a329cf489559bf1ffd51710469db6532ef3c3 # shrinks to ref orig = {13654: -29485, -24329: 12447, 28073: 17462, -11155: 3551, 11565: -26208, -15232: 7608, 29759: 20320, 438: -16354, 571: -10462, 7614: -10288, 23780: -23920, -6563: 29101, 26479: 3890, 26520: -11140, -17636: -22688, -9506: 1900, -30037: -31504, -26114: 12976, 22103: 27666, -16535: 28839, -16809: -30920, 20788: 18978, -20423: 26728, -31348: -22678, -9794: -21451, 16178: -20708, 31232: 29025, -30976: 4474, -29215: -26793, 852: -11649, -4772: -14366, -19460: -5289, -5325: 24856, 45: -20269, -23801: -29271, 27724: -17783, -23212: -18476, 30206: -16727, 435: -2093, 15924: 4857, -25633: 29368, -20962: -9007, -7339: 27158, -30115: -25527, 14804: -18380, -14522: 29035, 15562: 23077, -20118: 17616, 28098: 8432, -27495: 12350, 14609: -13814, -9145: 29859, -31933: 16305, 19469: -825, 2409: -19471, 20578: 22502, 7884: -12550, 11389: -14638, -21015: -16375, 9053: 16535, 4588: -7460, 9046: -8592, 9482: -10249, -30236: 32067, -5302: 27299, 30181: -6167, -29843: 7210, 16374: -32301, -25407: 20496, 2749: -11107, -5975: 27109, -27089: 2177, 8897: -31616, -29271: 2162, -31613: 20560, 31507: -14262, 21540: -25321, 24744: -7423, 26657: -26369, -12605: -22618, -27512: -21723, 291: -9951, -12495: -32742, 7539: 30444, -27269: -12562, 29899: 26866, -587: 20631, -31271: -32202, -15662: -21784, 28126: -31732, -9749: -6578, -13352: -5663, -5080: 21203, -31106: -8714, 29841: -16964, -11827: -13788, -24678: 4958, 6499: 17700, -5695: 1260, 12631: 29706, 21390: 794, 5009: -5889, -32578: -14971, -26389: -8078, 26546: 17151, -22373: 15689, 27572: 568, -5244: -1643, 23163: 11329, -28715: -15929, -25818: 12223, -4427: 28582, 26061: -32554, -14351: 5137, 3017: -15529, -23194: -19328, 30499: 5974, 16990: -31204, 28136: 23024, -13986: 5556, 12355: -10820, 2837: -15764, -8318: -22640, 19390: -32081, 5443: -11767, 14269: 4778, 12880: -8658, 23857: 15963, 29819: 14185, -28642: -14213, 1092: -1891, 3065: 7306, 5667: -16519, 13195: 30960, 30981: 3805, -18227: 17519, 26714: -10844, 1867: 3065, -21164: -23958, -27908: 23652, -3016: -25807, 21021: -24516, 601: 6650, 10464: -30444, -25383: 21397, 16149: -20990, -23678: 19268, 13651: -30926, -30193: 4015, -20550: -3813, 8984: 23024, 8529: 12538, 13423: 3073, 24037: -11619, -20993: -31582, -7056: -2892, -12795: 10504, -16197: 1330, -20748: -17973, -31199: 22341, 31286: -22643, 9674: -18049, -29206: -15460, -25215: -15832, 28334: 11339, 14680: 15220, -25943: 24920, 32275: -6093, 13259: 30579, -29041: -17489, 15886: 7941, 15683: 9359, -1635: 54, -30492: -21635, 10271: 18315, 13384: -5318, 31595: -23502, 14243: 5855, 10461: -11363, -3155: -29668, -5835: -8232, -28140: 19386, -761: 30096, -2515: 27267, -17737: -31871, 31096: -26754, -24336: 13642, -14011: -8588, -14996: 25507, 28759: 9825, -14214: 9160, -14712: -24558, 19038: -18469, -30816: -20086, 4334: -10671, -17006: 1184, -3730: 13058, 31026: -16485, 9580: -17771, -21186: 18345, -9664: -11262, -8480: 7648, 22920: -14965, -21022: -28133, -8744: -11234, -30252: -16231, -26305: 12363, -28149: -24604, -26462: 3796, 3057: -18784, 16634: 13983, 6987: -20371, 7469: 11214, 1205: -21956, -29086: 28404, 12269: 16334, 32493: -11094, 18386: -27104, -25066: -26762, -8850: 27225, -21958: -12209, -13409: -10100, -14283: -27726, -339: -26813, -25875: -8615, -9605: 8712, 10133: 21989, 9858: -12796, -19094: 32285, 32169: -26413, 2531: 30679, 15476: -23974, 14526: 26173, 32030: -8035, -32658: -23894, 32452: 31750, 8858: 3008, -22939: -30641, -570: 27228, -21127: -27648, 24710: 19973, 1390: 4422, 26123: 30745, -1229: -11664, -14679: 21300, -23645: -21514, -19979: -21143, 187: 26447, 1962: 103, -22968: 29896, 15464: 15061, 21532: 12811, -22803: -28425, 13579: -3285, -20628: -1077, -1080: 1008, 15835: -683, 29901: -2994, 8479: -3328, 21105: -27495, -3175: 19378, -30585: -24530, 17220: -24097, 30652: -32638, -21764: -4829, 24103: 19016, -21401: -27015, -31558: 18025, 30591: 11391, -22504: -23421, 5082: 27279, -2537: 27017, -12136: -749, 1815: -31786, -9416: -175, -12810: 30806, -9899: -2793, -32007: 30752, 20930: 30725, -28783: 8969, 29565: 2902, 18834: 2903, 31282: 30845, -10893: 28071, -20454: 1174, 27915: 5772, 29383: -1684, -5885: -19780, -9746: 17492, 8958: -7053, -1675: 24931, -20548: 29629, 10029: 19670, 372: 251, -22290: 1847, -22754: -8267, 15349: 14893, 6565: -16252, 5100: 31913, -21771: 247, 3407: -27092, 31264: 8619, -31498: 30586, -26457: -15280, 13900: -6472, 20237: 23494, -9435: -20123, 6560: 684, 6684: 13629, -19962: 31911, 7387: 22300, -16475: -211, 18073: -14359, 9010: -16589, -8927: 28464, -20438: -14947, 29302: -13068, 5174: -12114, -2684: 8886, 22145: -17371, -11264: -13950, -25938: -12728, -28145: -25911, -2871: -16462, -9775: -19757, 18920: 21013, 22571: 13793, -7253: 614, 1353: -19656, 22230: 14776, -25153: 4229, -26295: 15362, -25138: -16289, -26420: 21238, 32553: 2348, -17295: -15555, -18560: -30281, 25786: -5042, -10591: 10906, 17986: -1866, -32187: 14848, -8185: -18226, 28767: -25694, 15864: 740, -13565: -5281, 16351: -17855, 20798: 32488, 30621: 17130, -605: -12389, 11190: 6647, -5191: -7463, -17293: 21338, -1894: -29073, 10118: 15281, -24187: 12088, -13829: 32655, 19616: -29201, 32331: 26134, -22497: 12542, 2780: 29682, -8061: 20915, -15085: 21858, -2284: 1496, 12256: 14729, -12669: 8208, 12081: -20514, -19564: 21060, -5230: -3232, -47: 12452, -23297: 25490, 15469: 19166, -31330: -1486, 22627: 6048, 2274: 14307, -32613: -17602, 31993: -20703, 14408: -24288, -1425: 2191, -27528: 12719, -13137: -19771, -10087: -15533, 23123: 13133, -310: 28795, -17066: -28238, -323: -28130, 30008: -23016, 29855: 9227, -11934: -24563, -16278: -19539, 3943: -23354, 13038: 8483, -1376: -15228, 7177: -28754, 5920: -21813, 1028: -27574, -27086: -11996, -2451: 31603, -22198: 32494, 20534: 11352, -6499: 17474, -17125: -9124, 30067: 29674, -12170: -27056, 987: 10245, 20189: 7215, -17598: -31297, 20584: 32174, -27159: -25146, 15669: 14996, 22287: 32183, -17952: -27435, -20978: 29156, 17502: 23504, -2148: -3829, 14096: 8068, -25471: -11783, -10066: 25659, 14854: 17031, -16055: 30964, -24705: 9847, -21845: 27718, 30004: 14241, -2415: -3601, -23396: -26488, 27072: 4241, -25740: -23800, -32283: -6378, -20149: -2325, -29938: -25721, 26132: -5055, 4443: -8672, -4050: 19873, -936: -11208, -17559: 20749, 14497: 11691, 16966: 20137, -29672: 686, -11408: -10767, -2153: 29746, -31040: 2878, 2624: 10124, 7960: -27203, 17944: 18886, 5964: -30909, -6166: 25605, 13164: 10691, -27151: -18494, 6796: 10814, -9287: 8912, -27917: -2697, 21533: 22935, -27712: -24484, 8240: 27279, -10392: 24267, -5470: -32174, 18400: -29304, 6357: 9981, -10733: -30914, -20535: -266, -26868: -11399, -157: -13150, -7205: 6723, 23256: -6764, -786: 31308, -10664: 1606, -20685: -882, -24938: -1889, -7206: -3509, -25250: 31979, 30426: 128, 23897: -24001, -2859: -19488, -32217: 31472, 2593: 8890, 4407: 30506, 22878: 31925, -7560: -2864, -2411: -26849, 22106: -6447, 24278: 28527, 27516: -9012, 5476: -6024, 9147: 13764, 24213: -24869, -1759: -16068, -5603: -30129, 31029: -2919, -14714: 19182, -1590: 12635, -28358: 3872, -2090: -12305, -20911: -2417, 20313: 18181, -12831: -31538, 10130: 12759, -15468: 14679, 12923: 22142, 18271: -29174, -30962: 23155, 27775: -4512, -26395: -2421, -17588: 16263, 7453: 31385, 8023: 2389, -12214: 21076, 18059: 27701, -8734: 21859, 12513: -5333, 25322: -8656, 12712: 23597, 25917: -21636, -19326: -24361, 4360: -11045, -22272: 31718, -20938: -18069, 13566: -7383, -23839: -21705, -24263: 21476, -24653: 13628, -23521: 15327, -7348: -27475, -19318: -806, -8248: 14683, -29376: -8615, 24517: 4415, 19604: 19484, -32302: 22802, -24795: -13299, -12528: 32372, 13871: 5985, -8162: -19078, -22665: -32732, 9803: -4532, 27376: -14806, 15809: -23444, 16523: -6943, -25262: -4067, 12042: 6032, -13822: 21798, 11271: 16788, -6415: 783, 8921: -12257, -10523: 11184, 13024: 26551, -8164: -15301, 26059: 21139, -19775: -15038, 28467: 13920, 24798: 27943, 23346: 24954, 22060: -14719, 4525: -7210, -27468: -30621, 25871: -1553}