diff --git a/src/enc/backward_references/hq.rs b/src/enc/backward_references/hq.rs
index 45157431..3bbbe3e6 100755
--- a/src/enc/backward_references/hq.rs
+++ b/src/enc/backward_references/hq.rs
@@ -1244,24 +1244,17 @@ fn ZopfliCostModelSetFromCommands<AllocF: Allocator<floatX>>(
             let distcode: usize = ((commands[i]).dist_prefix_ as i32 & 0x3ff) as usize;
             let cmdcode: usize = (commands[i]).cmd_prefix_ as usize;
             let mut j: usize;
-            {
-                let _rhs = 1;
-                let _lhs = &mut histogram_cmd[cmdcode];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-            }
+            ::wrapping_add!(histogram_cmd[cmdcode], 1);
             if cmdcode >= 128usize {
-                let _rhs = 1;
-                let _lhs = &mut histogram_dist[distcode];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
+                ::wrapping_add!(histogram_dist[distcode], 1);
             }
             j = 0usize;
             while j < inslength {
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut histogram_literal
-                        [(ringbuffer[(pos.wrapping_add(j) & ringbuffer_mask)] as usize)];
-                    *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-                }
+                ::wrapping_add!(
+                    histogram_literal
+                        [(ringbuffer[(pos.wrapping_add(j) & ringbuffer_mask)] as usize)],
+                    1
+                );
                 j = j.wrapping_add(1);
             }
             pos = pos.wrapping_add(inslength.wrapping_add(copylength));
diff --git a/src/enc/block_splitter.rs b/src/enc/block_splitter.rs
index 4ab0b643..09d9e419 100755
--- a/src/enc/block_splitter.rs
+++ b/src/enc/block_splitter.rs
@@ -562,11 +562,7 @@ fn ClusterBlocks<
         while i < length {
             {
                 0i32;
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut block_lengths.slice_mut()[block_idx];
-                    *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-                }
+                ::wrapping_add!(block_lengths.slice_mut()[block_idx], 1);
                 if i.wrapping_add(1) == length
                     || block_ids[i] as i32 != block_ids[i.wrapping_add(1)] as i32
                 {
diff --git a/src/enc/brotli_bit_stream.rs b/src/enc/brotli_bit_stream.rs
index 24c01078..a36c4a1a 100755
--- a/src/enc/brotli_bit_stream.rs
+++ b/src/enc/brotli_bit_stream.rs
@@ -923,11 +923,7 @@ pub fn BrotliStoreHuffmanTree(
     );
     i = 0usize;
     while i < huffman_tree_size {
-        {
-            let _rhs = 1;
-            let _lhs = &mut huffman_tree_histogram[huffman_tree[i] as usize];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(huffman_tree_histogram[huffman_tree[i] as usize], 1);
         i = i.wrapping_add(1);
     }
     i = 0usize;
@@ -1665,15 +1661,9 @@ fn BuildAndStoreBlockSplitCode(
         {
             let type_code: usize = NextBlockTypeCode(&mut type_code_calculator, types[i]);
             if i != 0usize {
-                let _rhs = 1;
-                let _lhs = &mut type_histo[type_code];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-            }
-            {
-                let _rhs = 1;
-                let _lhs = &mut length_histo[BlockLengthPrefixCode(lengths[i]) as usize];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
+                ::wrapping_add!(type_histo[type_code], 1);
             }
+            ::wrapping_add!(length_histo[BlockLengthPrefixCode(lengths[i]) as usize], 1);
         }
         i = i.wrapping_add(1);
     }
@@ -1969,11 +1959,10 @@ fn EncodeContextMap<AllocU32: alloc::Allocator<u32>>(
     let mut histogram: [u32; 272] = [0; 272];
     i = 0usize;
     while i < num_rle_symbols {
-        {
-            let _rhs = 1;
-            let _lhs = &mut histogram[(rle_symbols.slice()[i] & kSymbolMask) as usize];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(
+            histogram[(rle_symbols.slice()[i] & kSymbolMask) as usize],
+            1
+        );
         i = i.wrapping_add(1);
     }
     {
@@ -2868,11 +2857,7 @@ pub fn BrotliStoreMetaBlockFast<Cb, Alloc: BrotliAlloc>(
                 j = cmd.insert_len_ as usize;
                 while j != 0usize {
                     {
-                        {
-                            let _rhs = 1;
-                            let _lhs = &mut histogram[input[(pos & mask)] as usize];
-                            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-                        }
+                        ::wrapping_add!(histogram[input[(pos & mask)] as usize], 1);
                         pos = pos.wrapping_add(1);
                     }
                     j = j.wrapping_sub(1);
diff --git a/src/enc/cluster.rs b/src/enc/cluster.rs
index ac348d86..72eea2c3 100755
--- a/src/enc/cluster.rs
+++ b/src/enc/cluster.rs
@@ -188,11 +188,10 @@ pub fn BrotliHistogramCombine<
         let best_idx2: u32 = (pairs[0]).idx2;
         HistogramSelfAddHistogram(out, (best_idx1 as usize), (best_idx2 as usize));
         (out[(best_idx1 as usize)]).set_bit_cost((pairs[0]).cost_combo);
-        {
-            let _rhs = cluster_size[(best_idx2 as usize)];
-            let _lhs = &mut cluster_size[(best_idx1 as usize)];
-            *_lhs = (*_lhs).wrapping_add(_rhs);
-        }
+        ::wrapping_add!(
+            cluster_size[(best_idx1 as usize)],
+            cluster_size[(best_idx2 as usize)]
+        );
         i = 0usize;
         while i < symbols_size {
             {
diff --git a/src/enc/compress_fragment.rs b/src/enc/compress_fragment.rs
index 594cca2a..96e003a3 100755
--- a/src/enc/compress_fragment.rs
+++ b/src/enc/compress_fragment.rs
@@ -52,11 +52,7 @@ fn BuildAndStoreLiteralPrefixCode<AllocHT: alloc::Allocator<HuffmanTree>>(
     if input_size < (1i32 << 15) as usize {
         i = 0usize;
         while i < input_size {
-            {
-                let _rhs = 1;
-                let _lhs = &mut histogram[input[i] as usize];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-            }
+            ::wrapping_add!(histogram[input[i] as usize], 1);
             i = i.wrapping_add(1);
         }
         histogram_total = input_size;
@@ -64,11 +60,7 @@ fn BuildAndStoreLiteralPrefixCode<AllocHT: alloc::Allocator<HuffmanTree>>(
         while i < 256usize {
             {
                 let adjust: u32 = (2u32).wrapping_mul(brotli_min_uint32_t(histogram[i], 11u32));
-                {
-                    let _rhs = adjust;
-                    let _lhs = &mut histogram[i];
-                    *_lhs = (*_lhs).wrapping_add(_rhs);
-                }
+                ::wrapping_add!(histogram[i], adjust);
                 histogram_total = histogram_total.wrapping_add(adjust as usize);
             }
             i = i.wrapping_add(1);
@@ -77,11 +69,7 @@ fn BuildAndStoreLiteralPrefixCode<AllocHT: alloc::Allocator<HuffmanTree>>(
         static kSampleRate: usize = 29usize;
         i = 0usize;
         while i < input_size {
-            {
-                let _rhs = 1;
-                let _lhs = &mut histogram[input[i] as usize];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-            }
+            ::wrapping_add!(histogram[input[i] as usize], 1);
             i = i.wrapping_add(kSampleRate);
         }
         histogram_total = input_size
@@ -93,11 +81,7 @@ fn BuildAndStoreLiteralPrefixCode<AllocHT: alloc::Allocator<HuffmanTree>>(
             {
                 let adjust: u32 = (1u32)
                     .wrapping_add((2u32).wrapping_mul(brotli_min_uint32_t(histogram[i], 11u32)));
-                {
-                    let _rhs = adjust;
-                    let _lhs = &mut histogram[i];
-                    *_lhs = (*_lhs).wrapping_add(_rhs);
-                }
+                ::wrapping_add!(histogram[i], adjust);
                 histogram_total = histogram_total.wrapping_add(adjust as usize);
             }
             i = i.wrapping_add(1);
@@ -153,11 +137,7 @@ fn EmitInsertLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[code];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[code], 1);
     } else if insertlen < 130usize {
         let tail: usize = insertlen.wrapping_sub(2);
         let nbits: u32 = Log2FloorNonZero(tail as u64).wrapping_sub(1);
@@ -177,11 +157,7 @@ fn EmitInsertLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[(inscode as usize)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[(inscode as usize)], 1);
     } else if insertlen < 2114usize {
         let tail: usize = insertlen.wrapping_sub(66);
         let nbits: u32 = Log2FloorNonZero(tail as u64);
@@ -198,11 +174,7 @@ fn EmitInsertLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[(code as usize)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[(code as usize)], 1);
     } else {
         BrotliWriteBits(depth[61] as usize, bits[61] as (u64), storage_ix, storage);
         BrotliWriteBits(
@@ -211,11 +183,7 @@ fn EmitInsertLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[61];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[61], 1);
     }
 }
 
@@ -271,11 +239,7 @@ fn EmitLongInsertLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[62];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[62], 1);
     } else {
         BrotliWriteBits(depth[63] as usize, bits[63] as (u64), storage_ix, storage);
         BrotliWriteBits(
@@ -284,11 +248,7 @@ fn EmitLongInsertLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[63];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[63], 1);
     }
 }
 
@@ -338,11 +298,7 @@ fn EmitDistance(
         storage,
     );
     BrotliWriteBits(nbits as usize, d.wrapping_sub(offset), storage_ix, storage);
-    {
-        let _rhs = 1;
-        let _lhs = &mut histo[(distcode as usize)];
-        *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-    }
+    ::wrapping_add!(histo[(distcode as usize)], 1);
 }
 
 fn EmitCopyLenLastDistance(
@@ -360,11 +316,7 @@ fn EmitCopyLenLastDistance(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[copylen.wrapping_sub(4)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[copylen.wrapping_sub(4)], 1);
     } else if copylen < 72usize {
         let tail: usize = copylen.wrapping_sub(8);
         let nbits: u32 = Log2FloorNonZero(tail as u64).wrapping_sub(1);
@@ -382,11 +334,7 @@ fn EmitCopyLenLastDistance(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[(code as usize)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[(code as usize)], 1);
     } else if copylen < 136usize {
         let tail: usize = copylen.wrapping_sub(8);
         let code: usize = (tail >> 5).wrapping_add(30);
@@ -398,16 +346,8 @@ fn EmitCopyLenLastDistance(
         );
         BrotliWriteBits(5usize, tail as u64 & 31, storage_ix, storage);
         BrotliWriteBits(depth[64] as usize, bits[64] as (u64), storage_ix, storage);
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[code];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[64];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[code], 1);
+        ::wrapping_add!(histo[64], 1);
     } else if copylen < 2120usize {
         let tail: usize = copylen.wrapping_sub(72);
         let nbits: u32 = Log2FloorNonZero(tail as u64);
@@ -425,16 +365,8 @@ fn EmitCopyLenLastDistance(
             storage,
         );
         BrotliWriteBits(depth[64] as usize, bits[64] as (u64), storage_ix, storage);
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[(code as usize)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[64];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[(code as usize)], 1);
+        ::wrapping_add!(histo[64], 1);
     } else {
         BrotliWriteBits(depth[39] as usize, bits[39] as (u64), storage_ix, storage);
         BrotliWriteBits(
@@ -444,16 +376,8 @@ fn EmitCopyLenLastDistance(
             storage,
         );
         BrotliWriteBits(depth[64] as usize, bits[64] as (u64), storage_ix, storage);
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[39];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[64];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[39], 1);
+        ::wrapping_add!(histo[64], 1);
     }
 }
 
@@ -479,11 +403,7 @@ fn EmitCopyLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[copylen.wrapping_add(14)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[copylen.wrapping_add(14)], 1);
     } else if copylen < 134usize {
         let tail: usize = copylen.wrapping_sub(6);
         let nbits: u32 = Log2FloorNonZero(tail as u64).wrapping_sub(1);
@@ -503,11 +423,7 @@ fn EmitCopyLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[(code as usize)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[(code as usize)], 1);
     } else if copylen < 2118usize {
         let tail: usize = copylen.wrapping_sub(70);
         let nbits: u32 = Log2FloorNonZero(tail as u64);
@@ -524,11 +440,7 @@ fn EmitCopyLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[(code as usize)];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[(code as usize)], 1);
     } else {
         BrotliWriteBits(depth[39] as usize, bits[39] as (u64), storage_ix, storage);
         BrotliWriteBits(
@@ -537,11 +449,7 @@ fn EmitCopyLen(
             storage_ix,
             storage,
         );
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[39];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(histo[39], 1);
     }
 }
 
@@ -551,11 +459,7 @@ fn ShouldMergeBlock(data: &[u8], len: usize, depths: &[u8]) -> bool {
     let mut i: usize;
     i = 0usize;
     while i < len {
-        {
-            let _rhs = 1;
-            let _lhs = &mut histo[data[i] as usize];
-            *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-        }
+        ::wrapping_add!(histo[data[i] as usize], 1);
         i = i.wrapping_add(kSampleRate);
     }
     {
@@ -858,11 +762,7 @@ fn BrotliCompressFragmentFastImpl<AllocHT: alloc::Allocator<HuffmanTree>>(
                                 storage_ix,
                                 storage,
                             );
-                            {
-                                let _rhs = 1u32;
-                                let _lhs = &mut cmd_histo[64];
-                                *_lhs = (*_lhs).wrapping_add(_rhs);
-                            }
+                            ::wrapping_add!(cmd_histo[64], 1);
                         } else {
                             EmitDistance(
                                 distance as usize,
diff --git a/src/enc/compress_fragment_two_pass.rs b/src/enc/compress_fragment_two_pass.rs
index 00750a08..f0d22565 100755
--- a/src/enc/compress_fragment_two_pass.rs
+++ b/src/enc/compress_fragment_two_pass.rs
@@ -418,11 +418,7 @@ fn ShouldCompress(input: &[u8], input_size: usize, num_literals: usize) -> bool
         let mut i: usize;
         i = 0usize;
         while i < input_size {
-            {
-                let _rhs = 1;
-                let _lhs = &mut literal_histo[input[i] as usize];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-            }
+            ::wrapping_add!(literal_histo[input[i] as usize], 1);
             i = i.wrapping_add(43);
         }
         BitsEntropy(&mut literal_histo[..], 256) < max_total_bit_cost
@@ -574,11 +570,7 @@ fn StoreCommands<AllocHT: alloc::Allocator<HuffmanTree>>(
     let mut i: usize;
     i = 0usize;
     while i < num_literals {
-        {
-            let _rhs = 1;
-            let _lhs = &mut lit_histo[literals[i] as usize];
-            *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-        }
+        ::wrapping_add!(lit_histo[literals[i] as usize], 1);
         i = i.wrapping_add(1);
     }
     BrotliBuildAndStoreHuffmanTreeFast(
@@ -596,34 +588,14 @@ fn StoreCommands<AllocHT: alloc::Allocator<HuffmanTree>>(
         {
             let code: u32 = commands[i] & 0xffu32;
             0i32;
-            {
-                let _rhs = 1;
-                let _lhs = &mut cmd_histo[code as usize];
-                *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-            }
+            ::wrapping_add!(cmd_histo[code as usize], 1);
         }
         i = i.wrapping_add(1);
     }
-    {
-        let _rhs = 1i32;
-        let _lhs = &mut cmd_histo[1];
-        *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-    }
-    {
-        let _rhs = 1i32;
-        let _lhs = &mut cmd_histo[2];
-        *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-    }
-    {
-        let _rhs = 1i32;
-        let _lhs = &mut cmd_histo[64];
-        *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-    }
-    {
-        let _rhs = 1i32;
-        let _lhs = &mut cmd_histo[84];
-        *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-    }
+    ::wrapping_add!(cmd_histo[1], 1);
+    ::wrapping_add!(cmd_histo[2], 1);
+    ::wrapping_add!(cmd_histo[64], 1);
+    ::wrapping_add!(cmd_histo[84], 1);
     BuildAndStoreCommandPrefixCode(
         &mut cmd_histo[..],
         &mut cmd_depths[..],
diff --git a/src/enc/encode.rs b/src/enc/encode.rs
index 8d5642eb..eed11d98 100755
--- a/src/enc/encode.rs
+++ b/src/enc/encode.rs
@@ -1402,11 +1402,7 @@ fn ShouldCompress(
         i = 0usize;
         while i < t {
             {
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut literal_histo[data[(pos as usize & mask)] as usize];
-                    *_lhs = (*_lhs).wrapping_add(_rhs as u32);
-                }
+                ::wrapping_add!(literal_histo[data[(pos as usize & mask)] as usize], 1);
                 pos = pos.wrapping_add(kSampleRate);
             }
             i = i.wrapping_add(1);
@@ -1800,16 +1796,8 @@ fn ChooseContextMap(
     i = 0usize;
     while i < 9usize {
         {
-            {
-                let _rhs = bigram_histo[i];
-                let _lhs = &mut monogram_histo[i.wrapping_rem(3)];
-                *_lhs = (*_lhs).wrapping_add(_rhs);
-            }
-            {
-                let _rhs = bigram_histo[i];
-                let _lhs = &mut two_prefix_histo[i.wrapping_rem(6)];
-                *_lhs = (*_lhs).wrapping_add(_rhs);
-            }
+            ::wrapping_add!(monogram_histo[i.wrapping_rem(3)], bigram_histo[i]);
+            ::wrapping_add!(two_prefix_histo[i.wrapping_rem(6)], bigram_histo[i]);
         }
         i = i.wrapping_add(1);
     }
diff --git a/src/enc/literal_cost.rs b/src/enc/literal_cost.rs
index 49a3332f..85a17bb2 100755
--- a/src/enc/literal_cost.rs
+++ b/src/enc/literal_cost.rs
@@ -33,11 +33,7 @@ fn DecideMultiByteStatsLevel(pos: usize, len: usize, mask: usize, data: &[u8]) -
     while i < len {
         {
             let c: usize = data[(pos.wrapping_add(i) & mask)] as usize;
-            {
-                let _rhs = 1;
-                let _lhs = &mut counts[UTF8Position(last_c, c, 2usize)];
-                *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-            }
+            ::wrapping_add!(counts[UTF8Position(last_c, c, 2usize)], 1);
             last_c = c;
         }
         i = i.wrapping_add(1);
@@ -71,16 +67,8 @@ fn EstimateBitCostsForLiteralsUTF8(
         while i < in_window {
             {
                 let c: usize = data[(pos.wrapping_add(i) & mask)] as usize;
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut histogram[utf8_pos][c];
-                    *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-                }
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut in_window_utf8[utf8_pos];
-                    *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-                }
+                ::wrapping_add!(histogram[utf8_pos][c], 1);
+                ::wrapping_add!(in_window_utf8[utf8_pos], 1);
                 utf8_pos = UTF8Position(last_c, c, max_utf8);
                 last_c = c;
             }
@@ -110,17 +98,12 @@ fn EstimateBitCostsForLiteralsUTF8(
                         & mask)] as i32
                 }) as usize;
                 let utf8_pos2: usize = UTF8Position(last_c, c, max_utf8);
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut histogram[utf8_pos2]
-                        [data[(pos.wrapping_add(i).wrapping_sub(window_half) & mask)] as usize];
-                    *_lhs = (*_lhs).wrapping_sub(_rhs as usize);
-                }
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut in_window_utf8[utf8_pos2];
-                    *_lhs = (*_lhs).wrapping_sub(_rhs as usize);
-                }
+                ::wrapping_sub!(
+                    histogram[utf8_pos2]
+                        [data[(pos.wrapping_add(i).wrapping_sub(window_half) & mask)] as usize],
+                    1
+                );
+                ::wrapping_sub!(in_window_utf8[utf8_pos2], 1);
             }
             if i.wrapping_add(window_half) < len {
                 let c: usize = data[(pos
@@ -134,17 +117,12 @@ fn EstimateBitCostsForLiteralsUTF8(
                     .wrapping_sub(2)
                     & mask)] as usize;
                 let utf8_pos2: usize = UTF8Position(last_c, c, max_utf8);
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut histogram[utf8_pos2]
-                        [data[(pos.wrapping_add(i).wrapping_add(window_half) & mask)] as usize];
-                    *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-                }
-                {
-                    let _rhs = 1;
-                    let _lhs = &mut in_window_utf8[utf8_pos2];
-                    *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-                }
+                ::wrapping_add!(
+                    histogram[utf8_pos2]
+                        [data[(pos.wrapping_add(i).wrapping_add(window_half) & mask)] as usize],
+                    1
+                );
+                ::wrapping_add!(in_window_utf8[utf8_pos2], 1);
             }
             {
                 let c: usize = (if i < 1 {
@@ -199,11 +177,7 @@ pub fn BrotliEstimateBitCostsForLiterals(
         let mut i: usize;
         i = 0usize;
         while i < in_window {
-            {
-                let _rhs = 1;
-                let _lhs = &mut histogram[data[(pos.wrapping_add(i) & mask)] as usize];
-                *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-            }
+            ::wrapping_add!(histogram[data[(pos.wrapping_add(i) & mask)] as usize], 1);
             i = i.wrapping_add(1);
         }
         i = 0usize;
@@ -211,21 +185,19 @@ pub fn BrotliEstimateBitCostsForLiterals(
             {
                 let mut histo: usize;
                 if i >= window_half {
-                    {
-                        let _rhs = 1;
-                        let _lhs = &mut histogram
-                            [data[(pos.wrapping_add(i).wrapping_sub(window_half) & mask)] as usize];
-                        *_lhs = (*_lhs).wrapping_sub(_rhs as usize);
-                    }
+                    ::wrapping_sub!(
+                        histogram
+                            [data[(pos.wrapping_add(i).wrapping_sub(window_half) & mask)] as usize],
+                        1
+                    );
                     in_window = in_window.wrapping_sub(1);
                 }
                 if i.wrapping_add(window_half) < len {
-                    {
-                        let _rhs = 1;
-                        let _lhs = &mut histogram
-                            [data[(pos.wrapping_add(i).wrapping_add(window_half) & mask)] as usize];
-                        *_lhs = (*_lhs).wrapping_add(_rhs as usize);
-                    }
+                    ::wrapping_add!(
+                        histogram
+                            [data[(pos.wrapping_add(i).wrapping_add(window_half) & mask)] as usize],
+                        1
+                    );
                     in_window = in_window.wrapping_add(1);
                 }
                 histo = histogram[data[(pos.wrapping_add(i) & mask)] as usize];
diff --git a/src/enc/metablock.rs b/src/enc/metablock.rs
index f74f0340..9db7b19f 100755
--- a/src/enc/metablock.rs
+++ b/src/enc/metablock.rs
@@ -642,11 +642,10 @@ fn BlockSplitterFinishBlock<
             xself.merge_last_count_ = 0usize;
             xself.target_block_size_ = xself.min_block_size_;
         } else {
-            {
-                let _rhs = xself.block_size_ as u32;
-                let _lhs = &mut split.lengths.slice_mut()[xself.num_blocks_.wrapping_sub(1)];
-                *_lhs = (*_lhs).wrapping_add(_rhs);
-            }
+            ::wrapping_add!(
+                split.lengths.slice_mut()[xself.num_blocks_.wrapping_sub(1)],
+                xself.block_size_ as u32
+            );
             histograms[xself.last_histogram_ix_[0]] = combined_histo[0].clone();
             xself.last_entropy_[0] = combined_entropy[0];
             if split.num_types == 1 {
diff --git a/src/enc/mod.rs b/src/enc/mod.rs
index a4fe0d0f..1d0d639c 100755
--- a/src/enc/mod.rs
+++ b/src/enc/mod.rs
@@ -347,3 +347,21 @@ where
     read_err?;
     Ok(total_out.unwrap())
 }
+
+#[macro_export]
+macro_rules! wrapping_add {
+    ($expr:expr, $increment:expr) => {{
+        let _rhs = $increment;
+        let _lhs = &mut $expr;
+        *_lhs = (*_lhs).wrapping_add(_rhs);
+    }};
+}
+
+#[macro_export]
+macro_rules! wrapping_sub {
+    ($expr:expr, $increment:expr) => {{
+        let _rhs = $increment;
+        let _lhs = &mut $expr;
+        *_lhs = (*_lhs).wrapping_sub(_rhs);
+    }};
+}