1 files changed, 39 insertions, 26 deletions

diff --git a/src/util/ans.cc b/src/util/ans.cc
index aa79e4b..779ef81 100644
--- a/src/util/ans.cc
+++ b/src/util/ans.cc
@@ -58,8 +58,7 @@ struct Stats {
   // the slot. Increments the symbol's count on the fly.
   void decode_lookup(uint32_t s, uint8_t* sym, uint32_t* p, uint32_t* r) {
     // upper_bound(s) - 1; cumul is strictly non-decreasing.
-    const uint32_t* it =
-        std::upper_bound(cumul, cumul + kNumSymbols + 1, s);
+    const uint32_t* it = std::upper_bound(cumul, cumul + kNumSymbols + 1, s);
     const int c = (int)(it - cumul) - 1;
     stats[c] += 1;
     *sym = (uint8_t)c;
@@ -97,27 +96,31 @@ inline void AppendU32BE(std::vector<uint8_t>* dst, uint32_t v) {
 }
 #endif
 
-}  // namespace
+} // namespace
 
 uint32_t PeekUncompressedSize(const uint8_t* src, size_t src_size) {
-  if (!src || src_size < 4) return 0;
+  if (!src || src_size < 4)
+    return 0;
   return ReadU32BE(src);
 }
 
-bool Decode(const uint8_t* src, size_t src_size,
-            uint8_t* dst, size_t dst_capacity,
-            size_t* out_size,
+bool Decode(const uint8_t* src, size_t src_size, uint8_t* dst,
+            size_t dst_capacity, size_t* out_size,
             const uint32_t* initial_counts) {
-  if (out_size) *out_size = 0;
-  if (!src || src_size < 4) return false;
+  if (out_size)
+    *out_size = 0;
+  if (!src || src_size < 4)
+    return false;
 
   const uint8_t* p = src;
   const uint8_t* end = src + src_size;
 
   const uint32_t output_size = ReadU32BE(p);
   p += 4;
-  if (output_size > dst_capacity) return false;
-  if (output_size > 0 && !dst) return false;
+  if (output_size > dst_capacity)
+    return false;
+  if (output_size > 0 && !dst)
+    return false;
 
   Stats stats;
   stats.init(initial_counts);
@@ -126,14 +129,16 @@ bool Decode(const uint8_t* src, size_t src_size,
   while (t < output_size) {
     const uint32_t chunk = std::min<uint32_t>(kChunkSize, output_size - t);
 
-    if (end - p < 4) return false;
+    if (end - p < 4)
+      return false;
     uint32_t s = ReadU32BE(p);
     p += 4;
 
     for (uint32_t i = 0; i < chunk; ++i) {
       if (s <= kMask) {
         // Pull in one renorm word.
-        if (end - p < 2) return false;
+        if (end - p < 2)
+          return false;
         s = (s << kBits) | (uint32_t)ReadU16BE(p);
         p += 2;
       }
@@ -144,31 +149,37 @@ bool Decode(const uint8_t* src, size_t src_size,
       s = proba * (s >> kBits) + residual;
     }
     // Final-state sanity check: catches stream corruption and model mismatch.
-    if (s != kInitState) return false;
+    if (s != kInitState)
+      return false;
     stats.normalize();
     t += chunk;
   }
 
-  if (out_size) *out_size = output_size;
+  if (out_size)
+    *out_size = output_size;
   return true;
 }
 
 #if defined(ANS_ENABLE_ENCODER)
 
 void Histogram(const uint8_t* src, size_t size, uint32_t* out_counts) {
-  if (!src || !out_counts) return;
-  for (size_t i = 0; i < size; ++i) out_counts[src[i]] += 1;
+  if (!src || !out_counts)
+    return;
+  for (size_t i = 0; i < size; ++i)
+    out_counts[src[i]] += 1;
 }
 
-bool Encode(const uint8_t* src, size_t size,
-            std::vector<uint8_t>* dst,
+bool Encode(const uint8_t* src, size_t size, std::vector<uint8_t>* dst,
             const uint32_t* initial_counts) {
-  if (!dst) return false;
+  if (!dst)
+    return false;
   dst->clear();
-  if (size > 0xffffffffu) return false;  // header is u32
+  if (size > 0xffffffffu)
+    return false; // header is u32
 
   AppendU32BE(dst, (uint32_t)size);
-  if (size == 0) return true;
+  if (size == 0)
+    return true;
 
   Stats stats;
   stats.init(initial_counts);
@@ -200,9 +211,11 @@ bool Encode(const uint8_t* src, size_t size,
     }
     // Invariant: final state must be > kMask so the decoder's first read is
     // a valid renormalized state.
-    if (s <= kMask) return false;
+    if (s <= kMask)
+      return false;
     AppendU32BE(dst, s);
-    for (size_t k = pos; k < chunk; ++k) AppendU16BE(dst, tmp[k]);
+    for (size_t k = pos; k < chunk; ++k)
+      AppendU16BE(dst, tmp[k]);
 
     stats.normalize();
     t += chunk;
@@ -210,6 +223,6 @@ bool Encode(const uint8_t* src, size_t size,
   return true;
 }
 
-#endif  // ANS_ENABLE_ENCODER
+#endif // ANS_ENABLE_ENCODER
 
-}  // namespace ans
+} // namespace ans