diff --git a/src/guillotine.rs b/src/guillotine.rs
index 76baf49..9a24cd6 100644
--- a/src/guillotine.rs
+++ b/src/guillotine.rs
@@ -131,7 +131,7 @@ impl Bin for GuillotineBin {
                 .iter()
                 .fold(0, |acc, fr| acc + fr.width as u64 * fr.length as u64) as f64;
 
-        (used_area / (used_area + free_area) as f64).powf(2.0 + self.free_rects.len() as f64 * 0.01)
+        (used_area / (used_area + free_area)).powf(2.0 + self.free_rects.len() as f64 * 0.01)
     }
 
     fn price(&self) -> usize {
@@ -511,12 +511,12 @@ impl GuillotineBin {
 
         // Use the given heuristic to decide which choice to make.
         let split_horizontal = match method {
-            SplitHeuristic::ShorterLeftoverAxis => (w <= h),
-            SplitHeuristic::LongerLeftoverAxis => (w > h),
-            SplitHeuristic::MinimizeArea => (rect.width as u64 * h > w * rect.length as u64),
-            SplitHeuristic::MaximizeArea => (rect.width as u64 * h <= w * rect.length as u64),
-            SplitHeuristic::ShorterAxis => (free_rect.width as u64 <= free_rect.length as u64),
-            SplitHeuristic::LongerAxis => (free_rect.width as u64 > free_rect.length as u64),
+            SplitHeuristic::ShorterLeftoverAxis => w <= h,
+            SplitHeuristic::LongerLeftoverAxis => w > h,
+            SplitHeuristic::MinimizeArea => rect.width as u64 * h > w * rect.length as u64,
+            SplitHeuristic::MaximizeArea => rect.width as u64 * h <= w * rect.length as u64,
+            SplitHeuristic::ShorterAxis => free_rect.width as u64 <= free_rect.length as u64,
+            SplitHeuristic::LongerAxis => free_rect.width as u64 > free_rect.length as u64,
         };
 
         let split_axis = if split_horizontal {
diff --git a/src/lib.rs b/src/lib.rs
index 3b344b4..cf72d8e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -669,10 +669,10 @@ where
 
         // Create a new unit with the bins of `self` and some of the bins of `other` injected in.
         let mut new_unit = OptimizerUnit {
-            bins: (&self.bins[..cross_dest])
+            bins: (self.bins[..cross_dest])
                 .iter()
-                .chain((&other.bins[cross_src_start..cross_src_end]).iter())
-                .chain((&self.bins[cross_dest..]).iter())
+                .chain((other.bins[cross_src_start..cross_src_end]).iter())
+                .chain((self.bins[cross_dest..]).iter())
                 .cloned()
                 .collect(),
             possible_stock_pieces: self.possible_stock_pieces,
@@ -715,7 +715,7 @@ where
                 .available_stock_pieces
                 .iter_mut()
                 .find(|sp| sp.quantity != Some(0) && bin.matches_stock_piece(sp));
-            let injected_cut_pieces = (&other.bins[cross_src_start..cross_src_end])
+            let injected_cut_pieces = (other.bins[cross_src_start..cross_src_end])
                 .iter()
                 .flat_map(Bin::cut_pieces);
             let num_removed_cut_pieces = bin.remove_cut_pieces(injected_cut_pieces);
diff --git a/src/maxrects.rs b/src/maxrects.rs
index a98979c..f073a29 100644
--- a/src/maxrects.rs
+++ b/src/maxrects.rs
@@ -320,9 +320,9 @@ impl MaxRectsBin {
             let fit = free_rect.fit_cut_piece(self.pattern_direction, cut_piece, prefer_rotated);
             if fit.is_upright() {
                 let leftover_horiz =
-                    (free_rect.width as isize - cut_piece.width as isize).abs() as usize;
+                    (free_rect.width as isize - cut_piece.width as isize).unsigned_abs();
                 let leftover_vert =
-                    (free_rect.length as isize - cut_piece.length as isize).abs() as usize;
+                    (free_rect.length as isize - cut_piece.length as isize).unsigned_abs();
                 let short_side_fit = cmp::min(leftover_horiz, leftover_vert);
                 let long_side_fit = cmp::max(leftover_horiz, leftover_vert);
 
@@ -339,9 +339,9 @@ impl MaxRectsBin {
                 }
             } else if fit.is_rotated() {
                 let leftover_horiz =
-                    (free_rect.width as isize - cut_piece.length as isize).abs() as usize;
+                    (free_rect.width as isize - cut_piece.length as isize).unsigned_abs();
                 let leftover_vert =
-                    (free_rect.length as isize - cut_piece.width as isize).abs() as usize;
+                    (free_rect.length as isize - cut_piece.width as isize).unsigned_abs();
                 let short_side_fit = cmp::min(leftover_horiz, leftover_vert);
                 let long_side_fit = cmp::max(leftover_horiz, leftover_vert);
 
@@ -380,9 +380,9 @@ impl MaxRectsBin {
             let fit = free_rect.fit_cut_piece(self.pattern_direction, cut_piece, prefer_rotated);
             if fit.is_upright() {
                 let leftover_horiz =
-                    (free_rect.width as isize - cut_piece.width as isize).abs() as usize;
+                    (free_rect.width as isize - cut_piece.width as isize).unsigned_abs();
                 let leftover_vert =
-                    (free_rect.length as isize - cut_piece.length as isize).abs() as usize;
+                    (free_rect.length as isize - cut_piece.length as isize).unsigned_abs();
                 let short_side_fit = cmp::min(leftover_horiz, leftover_vert);
                 let long_side_fit = cmp::max(leftover_horiz, leftover_vert);
 
@@ -399,9 +399,9 @@ impl MaxRectsBin {
                 }
             } else if fit.is_rotated() {
                 let leftover_horiz =
-                    (free_rect.width as isize - cut_piece.length as isize).abs() as usize;
+                    (free_rect.width as isize - cut_piece.length as isize).unsigned_abs();
                 let leftover_vert =
-                    (free_rect.length as isize - cut_piece.width as isize).abs() as usize;
+                    (free_rect.length as isize - cut_piece.width as isize).unsigned_abs();
                 let short_side_fit = cmp::min(leftover_horiz, leftover_vert);
                 let long_side_fit = cmp::max(leftover_horiz, leftover_vert);
 
@@ -448,9 +448,9 @@ impl MaxRectsBin {
 
             let fit = free_rect.fit_cut_piece(self.pattern_direction, cut_piece, prefer_rotated);
             if fit.is_upright() {
-                let leftover_horiz = (free_rect.width as i64 - cut_piece.width as i64).abs() as u64;
+                let leftover_horiz = (free_rect.width as i64 - cut_piece.width as i64).unsigned_abs();
                 let leftover_vert =
-                    (free_rect.length as i64 - cut_piece.length as i64).abs() as u64;
+                    (free_rect.length as i64 - cut_piece.length as i64).unsigned_abs();
                 let short_side_fit = cmp::min(leftover_horiz, leftover_vert);
 
                 if area_fit < best_area_fit
@@ -466,8 +466,8 @@ impl MaxRectsBin {
                 }
             } else if fit.is_rotated() {
                 let leftover_horiz =
-                    (free_rect.width as i64 - cut_piece.length as i64).abs() as u64;
-                let leftover_vert = (free_rect.length as i64 - cut_piece.width as i64).abs() as u64;
+                    (free_rect.width as i64 - cut_piece.length as i64).unsigned_abs();
+                let leftover_vert = (free_rect.length as i64 - cut_piece.width as i64).unsigned_abs();
                 let short_side_fit = cmp::min(leftover_horiz, leftover_vert);
 
                 if area_fit < best_area_fit