diff --git a/bin/crunch_x64.exe b/bin/crunch_x64.exe
index d227e88..bae89f6 100644
Binary files a/bin/crunch_x64.exe and b/bin/crunch_x64.exe differ
diff --git a/crnlib/crn_arealist.cpp b/crnlib/crn_arealist.cpp
index a3772e4..c98835c 100644
--- a/crnlib/crn_arealist.cpp
+++ b/crnlib/crn_arealist.cpp
@@ -8,8 +8,7 @@
 
 namespace crnlib {
 
-static void area_fatal_error(const char* pFunc, const char* pMsg, ...) {
-  pFunc;
+static void area_fatal_error(const char*, const char* pMsg, ...) {
   va_list args;
   va_start(args, pMsg);
 
diff --git a/crnlib/crn_assert.h b/crnlib/crn_assert.h
index 767e35b..66874e0 100644
--- a/crnlib/crn_assert.h
+++ b/crnlib/crn_assert.h
@@ -46,13 +46,11 @@ struct crnlib_assume_try {};
 
 #ifdef NDEBUG
 template <typename T>
-inline T crnlib_assert_range(T i, T m) {
-  m;
+inline T crnlib_assert_range(T i, T) {
   return i;
 }
 template <typename T>
-inline T crnlib_assert_range_incl(T i, T m) {
-  m;
+inline T crnlib_assert_range_incl(T i, T) {
   return i;
 }
 #else
diff --git a/crnlib/crn_clusterizer.h b/crnlib/crn_clusterizer.h
index 7111a3c..d80d508 100644
--- a/crnlib/crn_clusterizer.h
+++ b/crnlib/crn_clusterizer.h
@@ -652,10 +652,7 @@ class clusterizer {
       new_right_child *= (1.0f / right_weight);
 
       left_child = new_left_child;
-      left_weight = left_weight;
-
       right_child = new_right_child;
-      right_weight = right_weight;
 
       float total_variance = left_variance + right_variance;
       if (total_variance < .00001f)
diff --git a/crnlib/crn_color.h b/crnlib/crn_color.h
index 3a8c541..076b53f 100644
--- a/crnlib/crn_color.h
+++ b/crnlib/crn_color.h
@@ -469,9 +469,9 @@ struct scalar_type<color_quad<c, q> > {
   enum { cFlag = true };
   static inline void construct(color_quad<c, q>* p) {}
   static inline void construct(color_quad<c, q>* p, const color_quad<c, q>& init) { memcpy(p, &init, sizeof(color_quad<c, q>)); }
-  static inline void construct_array(color_quad<c, q>* p, uint n) { p, n; }
-  static inline void destruct(color_quad<c, q>* p) { p; }
-  static inline void destruct_array(color_quad<c, q>* p, uint n) { p, n; }
+  static inline void construct_array(color_quad<c, q>*, uint) {}
+  static inline void destruct(color_quad<c, q>*) {}
+  static inline void destruct_array(color_quad<c, q>*, uint) {}
 };
 
 typedef color_quad<uint8, int> color_quad_u8;
diff --git a/crnlib/crn_colorized_console.cpp b/crnlib/crn_colorized_console.cpp
index 925a65a..62ba333 100644
--- a/crnlib/crn_colorized_console.cpp
+++ b/crnlib/crn_colorized_console.cpp
@@ -21,9 +21,7 @@ void colorized_console::tick() {
 }
 
 #ifdef CRNLIB_USE_WIN32_API
-bool colorized_console::console_output_func(eConsoleMessageType type, const char* pMsg, void* pData) {
-  pData;
-
+bool colorized_console::console_output_func(eConsoleMessageType type, const char* pMsg, void*) {
   if (console::get_output_disabled())
     return true;
 
@@ -78,8 +76,7 @@ bool colorized_console::console_output_func(eConsoleMessageType type, const char
   return true;
 }
 #else
-bool colorized_console::console_output_func(eConsoleMessageType type, const char* pMsg, void* pData) {
-  pData;
+bool colorized_console::console_output_func(eConsoleMessageType type, const char* pMsg, void*) {
   if (console::get_output_disabled())
     return true;
 
diff --git a/crnlib/crn_comp.cpp b/crnlib/crn_comp.cpp
index 4c53023..37ef511 100644
--- a/crnlib/crn_comp.cpp
+++ b/crnlib/crn_comp.cpp
@@ -74,9 +74,6 @@ bool crn_comp::pack_color_endpoints(crnlib::vector<uint8>& packed_data, const cr
       return false;
   }
 
-  uint start_bits = codec.encode_get_total_bits_written();
-  start_bits;
-
   for (uint i = 0; i < residual_syms.size(); i++) {
     const uint sym = residual_syms[i];
     const uint table = ((i % 3) == 1) ? 1 : 0;
@@ -93,12 +90,12 @@ bool crn_comp::pack_color_endpoints(crnlib::vector<uint8>& packed_data, const cr
 bool crn_comp::pack_color_endpoints_etc(crnlib::vector<uint8>& packed_data, const crnlib::vector<uint16>& remapping) {
   crnlib::vector<uint32> remapped_endpoints(m_color_endpoints.size());
   for (uint i = 0; i < m_color_endpoints.size(); i++)
-    remapped_endpoints[remapping[i]] = m_color_endpoints[i] & 0x07000000 | m_color_endpoints[i] >> 3 & 0x001F1F1F;
+    remapped_endpoints[remapping[i]] = (m_color_endpoints[i] & 0x07000000) | (m_color_endpoints[i] >> 3 & 0x001F1F1F);
 
   symbol_histogram hist(32);
   for (uint32 prev_endpoint = 0, p = 0; p < remapped_endpoints.size(); p++) {
     for (uint32 _e = prev_endpoint, e = prev_endpoint = remapped_endpoints[p], c = 0; c < 4; c++, _e >>= 8, e >>= 8)
-      hist.inc_freq(e - _e & 0x1F);
+      hist.inc_freq((e - _e) & 0x1F);
   }
   static_huffman_data_model dm;
   dm.init(true, hist, 15);
@@ -107,7 +104,7 @@ bool crn_comp::pack_color_endpoints_etc(crnlib::vector<uint8>& packed_data, cons
   codec.encode_transmit_static_huffman_data_model(dm, false);
   for (uint32 prev_endpoint = 0, p = 0; p < remapped_endpoints.size(); p++) {
     for (uint32 _e = prev_endpoint, e = prev_endpoint = remapped_endpoints[p], c = 0; c < 4; c++, _e >>= 8, e >>= 8)
-      codec.encode(e - _e & 0x1F, dm);
+      codec.encode((e - _e) & 0x1F, dm);
   }
   codec.stop_encoding(false);
   packed_data.swap(codec.get_encoding_buf());
@@ -165,9 +162,6 @@ bool crn_comp::pack_alpha_endpoints(crnlib::vector<uint8>& packed_data, const cr
   if (!codec.encode_transmit_static_huffman_data_model(residual_dm, false))
     return false;
 
-  uint start_bits = codec.encode_get_total_bits_written();
-  start_bits;
-
   for (uint i = 0; i < residual_syms.size(); i++) {
     const uint sym = residual_syms[i];
     codec.encode(sym, residual_dm);
@@ -341,8 +335,8 @@ bool crn_comp::alias_images() {
   m_levels.resize(m_pParams->m_levels);
   m_total_blocks = 0;
   for (uint level = 0; level < m_pParams->m_levels; level++) {
-    uint blockHeight = (math::maximum(1U, m_pParams->m_height >> level) + 7 & ~7) >> 2;
-    m_levels[level].block_width = (math::maximum(1U, m_pParams->m_width >> level) + 7 & ~7) >> (m_has_etc_color_blocks ? 1 : 2);
+    uint blockHeight = ((math::maximum(1U, m_pParams->m_height >> level) + 7) & ~7) >> 2;
+    m_levels[level].block_width = ((math::maximum(1U, m_pParams->m_width >> level) + 7) & ~7) >> (m_has_etc_color_blocks ? 1 : 2);
     m_levels[level].first_block = m_total_blocks;
     m_levels[level].num_blocks = m_pParams->m_faces * m_levels[level].block_width * blockHeight;
     m_total_blocks += m_levels[level].num_blocks;
@@ -558,8 +552,8 @@ bool crn_comp::quantize_images() {
       image_u8& image = m_images[face][level];
       uint width = image.get_width();
       uint height = image.get_height();
-      uint blockWidth = (width + 7 & ~7) >> 2;
-      uint blockHeight = (height + 7 & ~7) >> 2;
+      uint blockWidth = ((width + 7) & ~7) >> 2;
+      uint blockHeight = ((height + 7) & ~7) >> 2;
       for (uint by = 0; by < blockHeight; by++) {
         for (uint y0 = by << 2, bx = 0; bx < blockWidth; bx++, b++) {
           for (uint t = 0, x0 = bx << 2, dy = 0; dy < 4; dy++) {
@@ -634,8 +628,8 @@ static void remap_color_endpoints(uint16* remapping, const optimize_color_params
   for (uint similarity_base = (uint)(4000 * (1.0f + weight)), total_frequency_normalizer = 0; remaining.size();) {
     const optimize_color_params::unpacked_endpoint& e_front = unpacked_endpoints[chosen.front()];
     const optimize_color_params::unpacked_endpoint& e_back = unpacked_endpoints[chosen.back()];
-    uint16 selected_index;
-    uint64 best_value = 0, selected_similarity_front, selected_similarity_back;
+    uint16 selected_index = 0;
+    uint64 best_value = 0, selected_similarity_front = 0, selected_similarity_back = 0;
     for (uint16 i = 0; i < remaining.size(); i++) {
       uint remaining_index = remaining[i];
       const optimize_color_params::unpacked_endpoint& e_remaining = unpacked_endpoints[remaining_index];
@@ -730,7 +724,7 @@ void crn_comp::optimize_color_selectors() {
     D4[i] = d[(i ^ i >> 4) & 3] + d[(i >> 2 ^ i >> 6) & 3];
   uint8 D8[0x10000];
   for (uint32 i = 0; i < 0x10000; i++)
-    D8[i] = D4[i >> 8 & 0xF0 | i >> 4 & 0xF] + D4[i >> 4 & 0xF0 | i & 0xF];
+    D8[i] = D4[(i >> 8 & 0xF0) | (i >> 4 & 0xF)] + D4[(i >> 4 & 0xF0) | (i & 0xF)];
 
   crnlib::vector<uint32> selectors(n);
   crnlib::vector<uint16> indices(n);
@@ -744,10 +738,10 @@ void crn_comp::optimize_color_selectors() {
     uint min_error = cUINT32_MAX;
     for (uint16 i = 0; i < left; i++) {
       uint32 selector = selectors[i];
-      uint8 d0 = D8[selector >> 16 & 0xFF00 | selected_selector >> 24 & 0xFF];
-      uint8 d1 = D8[selector >> 8 & 0xFF00 | selected_selector >> 16 & 0xFF];
-      uint8 d2 = D8[selector & 0xFF00 | selected_selector >> 8 & 0xFF];
-      uint8 d3 = D8[selector << 8 & 0xFF00 | selected_selector & 0xFF];
+      uint8 d0 = D8[(selector >> 16 & 0xFF00) | (selected_selector >> 24 & 0xFF)];
+      uint8 d1 = D8[(selector >> 8 & 0xFF00) | (selected_selector >> 16 & 0xFF)];
+      uint8 d2 = D8[(selector & 0xFF00) | (selected_selector >> 8 & 0xFF)];
+      uint8 d3 = D8[(selector << 8 & 0xFF00) | (selected_selector & 0xFF)];
       uint error = d0 + d1 + d2 + d3;
       if (error < min_error) {
         min_error = error;
@@ -872,8 +866,8 @@ static void remap_alpha_endpoints(uint16* remapping, const optimize_alpha_params
   for (uint similarity_base = (uint)(1000 * (1.0f + weight)), total_frequency_normalizer = 0; remaining.size();) {
     const optimize_alpha_params::unpacked_endpoint& e_front = unpacked_endpoints[chosen.front()];
     const optimize_alpha_params::unpacked_endpoint& e_back = unpacked_endpoints[chosen.back()];
-    uint16 selected_index;
-    uint64 best_value = 0, selected_similarity_front, selected_similarity_back;
+    uint16 selected_index = 0;
+    uint64 best_value = 0, selected_similarity_front = 0, selected_similarity_back = 0;
     for (uint16 i = 0; i < remaining.size(); i++) {
       uint remaining_index = remaining[i];
       const optimize_alpha_params::unpacked_endpoint& e_remaining = unpacked_endpoints[remaining_index];
@@ -991,7 +985,7 @@ void crn_comp::optimize_alpha_selectors() {
     for (uint16 i = 0; i < left; i++) {
       uint error = 0;
       for (uint64 selector = selectors[i] << 6, delta_selector = selected_selector, j = 0; j < 8; j++, selector >>= 6, delta_selector >>= 6)
-        error += D6[selector & 0xFC0 | delta_selector & 0x3F];
+        error += D6[(selector & 0xFC0) | (delta_selector & 0x3F)];
       if (error < min_error) {
         min_error = error;
         selected_index = i;
@@ -1269,11 +1263,6 @@ bool crn_comp::compress_internal() {
   return true;
 }
 
-bool crn_comp::compress_init(const crn_comp_params& params) {
-  params;
-  return true;
-}
-
 bool crn_comp::compress_pass(const crn_comp_params& params, float* pEffective_bitrate) {
   clear();
 
diff --git a/crnlib/crn_comp.h b/crnlib/crn_comp.h
index 49ab4fe..14d03de 100644
--- a/crnlib/crn_comp.h
+++ b/crnlib/crn_comp.h
@@ -21,7 +21,7 @@ class crn_comp : public itexture_comp {
 
   virtual const char* get_ext() const { return "CRN"; }
 
-  virtual bool compress_init(const crn_comp_params& params);
+  virtual bool compress_init(const crn_comp_params&) { return true; };
   virtual bool compress_pass(const crn_comp_params& params, float* pEffective_bitrate);
   virtual void compress_deinit();
 
diff --git a/crnlib/crn_dxt1.cpp b/crnlib/crn_dxt1.cpp
index de488ec..4629a7c 100644
--- a/crnlib/crn_dxt1.cpp
+++ b/crnlib/crn_dxt1.cpp
@@ -1625,8 +1625,6 @@ void dxt1_endpoint_optimizer::try_combinatorial_encoding() {
 // The fourth (transparent) color in 3 color "transparent" blocks is black, which can be optionally exploited for small gains in DXT1 mode if the caller
 // doesn't actually use alpha. (But not in DXT5 mode, because 3-color blocks aren't permitted by GPU's for DXT5.)
 bool dxt1_endpoint_optimizer::try_alpha_as_black_optimization() {
-  const params* pOrig_params = m_pParams;
-  pOrig_params;
   results* pOrig_results = m_pResults;
 
   uint num_dark_colors = 0;
diff --git a/crnlib/crn_dxt_hc.cpp b/crnlib/crn_dxt_hc.cpp
index 94b473f..edcd5ea 100644
--- a/crnlib/crn_dxt_hc.cpp
+++ b/crnlib/crn_dxt_hc.cpp
@@ -231,7 +231,7 @@ bool dxt_hc::compress(
   return true;
 }
 
-void dxt_hc::determine_tiles_task(uint64 data, void* pData_ptr) {
+void dxt_hc::determine_tiles_task(uint64 data, void*) {
   uint num_tasks = m_pTask_pool->get_num_threads() + 1;
   uint offsets[9] = {0, 16, 32, 48, 0, 32, 64, 96, 64};
   uint8 tiles[8][4] = {{8}, {6, 7}, {4, 5}, {6, 1, 3}, {7, 0, 2}, {4, 2, 3}, {5, 0, 1}, {0, 2, 1, 3}};
@@ -376,7 +376,7 @@ void dxt_hc::determine_tiles_task(uint64 data, void* pData_ptr) {
   }
 }
 
-void dxt_hc::determine_tiles_task_etc(uint64 data, void* pData_ptr) {
+void dxt_hc::determine_tiles_task_etc(uint64 data, void*) {
   uint num_tasks = m_pTask_pool->get_num_threads() + 1;
   uint offsets[5] = {0, 8, 16, 24, 16};
   uint8 tiles[3][2] = {{4}, {2, 3}, {0, 1}};
@@ -399,11 +399,11 @@ void dxt_hc::determine_tiles_task_etc(uint64 data, void* pData_ptr) {
 
   for (uint level = 0; level < m_params.m_num_levels; level++) {
     float weight = m_params.m_levels[level].m_weight;
-    uint b = m_params.m_levels[level].m_first_block + m_params.m_levels[level].m_num_blocks * data / num_tasks & ~1;
-    uint bEnd = m_params.m_levels[level].m_first_block + m_params.m_levels[level].m_num_blocks * (data + 1) / num_tasks & ~1;
+    uint b = (m_params.m_levels[level].m_first_block + m_params.m_levels[level].m_num_blocks * data / num_tasks) & ~1;
+    uint bEnd = (m_params.m_levels[level].m_first_block + m_params.m_levels[level].m_num_blocks * (data + 1) / num_tasks) & ~1;
     for (; b < bEnd; b += 2) {
       for (uint p = 0; p < 16; p++)
-        tilePixels[p] = m_blocks[b >> 1][p << 2 & 12 | p >> 2];
+        tilePixels[p] = m_blocks[b >> 1][(p << 2 & 12) | p >> 2];
       memcpy(tilePixels + 16, m_blocks[b >> 1], 64);
       for (uint t = 0; t < 5; t++) {
         params.m_pSrc_pixels = tilePixels + offsets[t];
@@ -483,14 +483,12 @@ void dxt_hc::determine_tiles_task_etc(uint64 data, void* pData_ptr) {
   }
 }
 
-void dxt_hc::determine_color_endpoint_codebook_task(uint64 data, void* pData_ptr) {
-  pData_ptr;
+void dxt_hc::determine_color_endpoint_codebook_task(uint64 data, void*) {
   const uint thread_index = static_cast<uint>(data);
 
   if (!m_has_color_blocks)
     return;
 
-  uint total_empty_clusters = 0;
   for (uint cluster_index = 0; cluster_index < m_color_clusters.size(); cluster_index++) {
     if (m_canceled)
       return;
@@ -580,7 +578,7 @@ void dxt_hc::determine_color_endpoint_codebook_task(uint64 data, void* pData_ptr
   }
 }
 
-void dxt_hc::determine_color_endpoint_codebook_task_etc(uint64 data, void* pData_ptr) {
+void dxt_hc::determine_color_endpoint_codebook_task_etc(uint64 data, void*) {
   uint num_tasks = m_pTask_pool->get_num_threads() + 1;
   uint8 delta[8][2] = { {2, 8}, {5, 17}, {9, 29}, {13, 42}, {18, 60}, {24, 80}, {33, 106}, {47, 183} };
   int scan[] = {-1, 0, 1};
@@ -681,7 +679,7 @@ void dxt_hc::determine_color_endpoints() {
       if (m_endpoint_indices[b].reference >> 1) {
         color_quad_u8 mirror[16];
         for (uint p = 0; p < 16; p++)
-          mirror[p] = m_blocks[b >> 1][p << 2 & 12 | p >> 2];
+          mirror[p] = m_blocks[b >> 1][(p << 2 & 12) | p >> 2];
         memcpy(m_blocks[b >> 1], mirror, 64);
       }
       m_endpoint_indices[b].reference = 0;
@@ -693,8 +691,7 @@ void dxt_hc::determine_color_endpoints() {
   m_pTask_pool->join();
 }
 
-void dxt_hc::determine_alpha_endpoint_codebook_task(uint64 data, void* pData_ptr) {
-  pData_ptr;
+void dxt_hc::determine_alpha_endpoint_codebook_task(uint64 data, void*) {
   const uint thread_index = static_cast<uint>(data);
 
   for (uint cluster_index = 0; cluster_index < m_alpha_clusters.size(); cluster_index++) {
@@ -923,7 +920,7 @@ void dxt_hc::create_color_selector_codebook() {
   }
 
   uint num_tasks = m_pTask_pool->get_num_threads() + 1;
-  crnlib::vector<crnlib::vector<color_selector_details>> selector_details(num_tasks);
+  crnlib::vector<crnlib::vector<color_selector_details> > selector_details(num_tasks);
   for (uint t = 0; t < num_tasks; t++) {
     selector_details[t].resize(m_color_selectors.size());
     m_pTask_pool->queue_object_task(this, &dxt_hc::create_color_selector_codebook_task, t, &selector_details[t]);
@@ -1037,7 +1034,7 @@ void dxt_hc::create_alpha_selector_codebook() {
   }
 
   uint num_tasks = m_pTask_pool->get_num_threads() + 1;
-  crnlib::vector<crnlib::vector<alpha_selector_details>> selector_details(num_tasks);
+  crnlib::vector<crnlib::vector<alpha_selector_details> > selector_details(num_tasks);
   for (uint t = 0; t < num_tasks; t++) {
     selector_details[t].resize(m_alpha_selectors.size());
     m_pTask_pool->queue_object_task(this, &dxt_hc::create_alpha_selector_codebook_task, t, &selector_details[t]);
diff --git a/crnlib/crn_dxt_image.cpp b/crnlib/crn_dxt_image.cpp
index b8498f2..8abe3aa 100644
--- a/crnlib/crn_dxt_image.cpp
+++ b/crnlib/crn_dxt_image.cpp
@@ -863,7 +863,7 @@ void dxt_image::set_pixel(uint x, uint y, const color_quad_u8& c, bool perceptua
         uint best_selector = 0;
 
         for (uint i = 0; i < cDXT5SelectorValues; i++) {
-          uint error = labs(values[i] - c[comp_index]);  // no need to square
+          uint error = labs((int)values[i] - (int)c[comp_index]);  // no need to square
 
           if (error < best_error) {
             best_error = error;
@@ -1096,7 +1096,7 @@ void dxt_image::set_block_pixels(
     }
 
     if (m_format == cDXT5A)
-      ryg_dxt::sCompressDXT5ABlock((sU8*)pElement, (const sU32*)pixels, 0);
+      ryg_dxt::sCompressDXT5ABlock((sU8*)pElement, (const sU32*)pixels);
     else
       ryg_dxt::sCompressDXTBlock((sU8*)pElement, (const sU32*)pixels, m_format == cDXT5, 0);
   } else if ((p.m_compressor == cCRNDXTCompressorCRNF) && (m_format != cDXT1A)) {
diff --git a/crnlib/crn_dynamic_string.cpp b/crnlib/crn_dynamic_string.cpp
index e7ce807..71d37fe 100644
--- a/crnlib/crn_dynamic_string.cpp
+++ b/crnlib/crn_dynamic_string.cpp
@@ -6,10 +6,8 @@
 namespace crnlib {
 dynamic_string g_empty_dynamic_string;
 
-dynamic_string::dynamic_string(eVarArg dummy, const char* p, ...)
+dynamic_string::dynamic_string(eVarArg, const char* p, ...)
     : m_buf_size(0), m_len(0), m_pStr(NULL) {
-  dummy;
-
   CRNLIB_ASSERT(p);
 
   va_list args;
diff --git a/crnlib/crn_etc.cpp b/crnlib/crn_etc.cpp
index 3f144aa..53d6c73 100644
--- a/crnlib/crn_etc.cpp
+++ b/crnlib/crn_etc.cpp
@@ -1014,7 +1014,7 @@ bool etc1_optimizer::evaluate_solution_fast(const etc1_solution_coordinates& coo
     const color_quad_u8* pSrc_pixels = m_pParams->m_pSrc_pixels;
     if ((m_pSorted_luma[n - 1] * 2) < block_inten_midpoints[0]) {
       if (block_inten[0] > m_pSorted_luma[n - 1]) {
-        const uint min_error = labs(block_inten[0] - m_pSorted_luma[n - 1]);
+        const uint min_error = block_inten[0] - m_pSorted_luma[n - 1];
         if (min_error >= trial_solution.m_error)
           continue;
       }
@@ -1025,7 +1025,7 @@ bool etc1_optimizer::evaluate_solution_fast(const etc1_solution_coordinates& coo
         total_error += color::elucidian_distance(block_colors[0], pSrc_pixels[c], false);
     } else if ((m_pSorted_luma[0] * 2) >= block_inten_midpoints[2]) {
       if (m_pSorted_luma[0] > block_inten[3]) {
-        const uint min_error = labs(m_pSorted_luma[0] - block_inten[3]);
+        const uint min_error = m_pSorted_luma[0] - block_inten[3];
         if (min_error >= trial_solution.m_error)
           continue;
       }
@@ -1117,9 +1117,7 @@ static void DitherBlock(color_quad_u8* dest, const color_quad_u8* block) {
 }
 
 static uint etc1_decode_value(uint diff, uint inten, uint selector, uint packed_c) {
-  const uint limit = diff ? 32 : 16;
-  limit;
-  CRNLIB_ASSERT((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < limit));
+  CRNLIB_ASSERT((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < (diff ? 32 : 16)));
   int c;
   if (diff)
     c = (packed_c >> 2) | (packed_c << 3);
@@ -1137,7 +1135,7 @@ void pack_etc1_block_init() {
     for (uint inten = 0; inten < 8; inten++) {
       for (uint selector = 0; selector < 4; selector++) {
         const uint inverse_table_index = diff + (inten << 1) + (selector << 4);
-        for (uint color = 0; color < 256; color++) {
+        for (int color = 0; color < 256; color++) {
           uint best_error = cUINT32_MAX, best_packed_c = 0;
           for (uint packed_c = 0; packed_c < limit; packed_c++) {
             int v = etc1_decode_value(diff, inten, selector, packed_c);
diff --git a/crnlib/crn_file_utils.cpp b/crnlib/crn_file_utils.cpp
index 415f979..f763901 100644
--- a/crnlib/crn_file_utils.cpp
+++ b/crnlib/crn_file_utils.cpp
@@ -409,8 +409,9 @@ bool file_utils::remove_extension(dynamic_string& filename) {
 }
 
 bool file_utils::create_path(const dynamic_string& fullpath) {
+#ifdef WIN32
   bool got_unc = false;
-  got_unc;
+#endif
   dynamic_string cur_path;
 
   const int l = fullpath.get_len();
diff --git a/crnlib/crn_helpers.h b/crnlib/crn_helpers.h
index b9062a0..b18f3b3 100644
--- a/crnlib/crn_helpers.h
+++ b/crnlib/crn_helpers.h
@@ -46,7 +46,7 @@ inline void construct_array(T* p, uint n, const U& init) {
 
 template <typename T>
 inline void destruct(T* p) {
-  p;
+  (void)p;
   p->~T();
 }
 
diff --git a/crnlib/crn_image.h b/crnlib/crn_image.h
index b545b99..51ed4d9 100644
--- a/crnlib/crn_image.h
+++ b/crnlib/crn_image.h
@@ -335,7 +335,7 @@ class image {
     uint height = math::minimum(m_height - dst_y, src.get_height() - src_y);
 
     bool success = unclipped_blit(src_x, src_y, width, height, dst_x, dst_y, src);
-    success;
+    (void)success;
     CRNLIB_ASSERT(success);
 
     return true;
@@ -360,7 +360,7 @@ class image {
         src_rect.get_left(), src_rect.get_top(),
         math::minimum(src_rect.get_width(), dst_rect.get_width()), math::minimum(src_rect.get_height(), dst_rect.get_height()),
         dst_rect.get_left(), dst_rect.get_top(), src);
-    success;
+    (void)success;
     CRNLIB_ASSERT(success);
 
     return true;
diff --git a/crnlib/crn_image_utils.cpp b/crnlib/crn_image_utils.cpp
index bad8b30..b032b7f 100644
--- a/crnlib/crn_image_utils.cpp
+++ b/crnlib/crn_image_utils.cpp
@@ -752,8 +752,8 @@ double compute_ssim(const image_u8& a, const image_u8& b, int channel_index) {
 }
 
 void print_ssim(const image_u8& src_img, const image_u8& dst_img) {
-  src_img;
-  dst_img;
+  (void)src_img;
+  (void)dst_img;
   //double y_ssim = compute_ssim(src_img, dst_img, -1);
   //console::printf("Luma MSSIM: %f, Scaled: %f", y_ssim, (y_ssim - .8f) / .2f);
 
diff --git a/crnlib/crn_jpgd.cpp b/crnlib/crn_jpgd.cpp
index ec85ad9..762f884 100644
--- a/crnlib/crn_jpgd.cpp
+++ b/crnlib/crn_jpgd.cpp
@@ -587,7 +587,7 @@ inline int jpeg_decoder::huff_decode(huff_tables* pH, int& extra_bits) {
 
 // Tables and macro used to fully decode the DPCM differences.
 static const int s_extend_test[16] = {0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000};
-static const int s_extend_offset[16] = {0, ((-1) << 1) + 1, ((-1) << 2) + 1, ((-1) << 3) + 1, ((-1) << 4) + 1, ((-1) << 5) + 1, ((-1) << 6) + 1, ((-1) << 7) + 1, ((-1) << 8) + 1, ((-1) << 9) + 1, ((-1) << 10) + 1, ((-1) << 11) + 1, ((-1) << 12) + 1, ((-1) << 13) + 1, ((-1) << 14) + 1, ((-1) << 15) + 1};
+static const int s_extend_offset[16] = {0, 1 - (1 << 1), 1 - (1 << 2), 1 - (1 << 3), 1 - (1 << 4), 1 - (1 << 5), 1 - (1 << 6), 1 - (1 << 7), 1 - (1 << 8), 1 - (1 << 9), 1 - (1 << 10), 1 - (1 << 11), 1 - (1 << 12), 1 - (1 << 13), 1 - (1 << 14), 1 - (1 << 15)};
 static const int s_extend_mask[] = {0, (1 << 0), (1 << 1), (1 << 2), (1 << 3), (1 << 4), (1 << 5), (1 << 6), (1 << 7), (1 << 8), (1 << 9), (1 << 10), (1 << 11), (1 << 12), (1 << 13), (1 << 14), (1 << 15), (1 << 16)};
 // The logical AND's in this macro are to shut up static code analysis (aren't really necessary - couldn't find another way to do this)
 #define JPGD_HUFF_EXTEND(x, s) (((x) < s_extend_test[s & 15]) ? ((x) + s_extend_offset[s & 15]) : (x))
diff --git a/crnlib/crn_ktx_texture.cpp b/crnlib/crn_ktx_texture.cpp
index e61c72d..5b398f6 100644
--- a/crnlib/crn_ktx_texture.cpp
+++ b/crnlib/crn_ktx_texture.cpp
@@ -362,9 +362,6 @@ bool ktx_texture::read_from_stream(data_stream_serializer& serializer) {
   if ((!mip0_row_blocks) || (!mip0_col_blocks))
     return false;
 
-  const uint mip0_depth = CRNLIB_MAX(1, m_header.m_pixelDepth);
-  mip0_depth;
-
   bool has_valid_image_size_fields = true;
   bool disable_mip_and_cubemap_padding = false;
 
diff --git a/crnlib/crn_mem.cpp b/crnlib/crn_mem.cpp
index 2e52d5b..d32ea08 100644
--- a/crnlib/crn_mem.cpp
+++ b/crnlib/crn_mem.cpp
@@ -56,9 +56,7 @@ static mem_stat_t update_total_allocated(int block_delta, mem_stat_t byte_delta)
 }
 #endif  // CRNLIB_MEM_STATS
 
-static void* crnlib_default_realloc(void* p, size_t size, size_t* pActual_size, bool movable, void* pUser_data) {
-  pUser_data;
-
+static void* crnlib_default_realloc(void* p, size_t size, size_t* pActual_size, bool movable, void*) {
   void* p_new;
 
   if (!p) {
@@ -106,90 +104,12 @@ static void* crnlib_default_realloc(void* p, size_t size, size_t* pActual_size,
   return p_new;
 }
 
-static size_t crnlib_default_msize(void* p, void* pUser_data) {
-  pUser_data;
+static size_t crnlib_default_msize(void* p, void*) {
   return p ? _msize(p) : 0;
 }
 
-#if 0
-   static __declspec(thread) void *g_pBuf;
-   static __declspec(thread) size_t g_buf_size;
-   static __declspec(thread) size_t g_buf_ofs;
-
-   static size_t crnlib_nofree_msize(void* p, void* pUser_data)
-   {
-      pUser_data;
-      return p ? ((const size_t*)p)[-1] : 0;
-   }
-
-   static void* crnlib_nofree_realloc(void* p, size_t size, size_t* pActual_size, bool movable, void* pUser_data)
-   {
-      pUser_data;
-
-      void* p_new;
-
-      if (!p)
-      {
-         size = math::align_up_value(size, CRNLIB_MIN_ALLOC_ALIGNMENT);
-         size_t actual_size = sizeof(size_t)*2 + size;
-         size_t num_remaining = g_buf_size - g_buf_ofs;
-         if (num_remaining < actual_size)
-         {
-            g_buf_size = CRNLIB_MAX(actual_size, 32*1024*1024);
-            g_buf_ofs = 0;
-            g_pBuf = malloc(g_buf_size);
-            if (!g_pBuf)
-               return NULL;
-         }
-
-         p_new = (uint8*)g_pBuf + g_buf_ofs;
-         ((size_t*)p_new)[1] = size;
-         p_new = (size_t*)p_new + 2;
-         g_buf_ofs += actual_size;
-
-         if (pActual_size)
-            *pActual_size = size;
-
-         CRNLIB_ASSERT(crnlib_nofree_msize(p_new, NULL) == size);
-      }
-      else if (!size)
-      {
-         if (pActual_size)
-            *pActual_size = 0;
-         p_new = NULL;
-      }
-      else
-      {
-         size_t cur_size = crnlib_nofree_msize(p, NULL);
-         p_new = p;
-
-         if (!movable)
-            return NULL;
-
-         if (size > cur_size)
-         {
-            p_new = crnlib_nofree_realloc(NULL, size, NULL, true, NULL);
-            if (!p_new)
-               return NULL;
-
-            memcpy(p_new, p, cur_size);
-
-            cur_size = size;
-         }
-
-         if (pActual_size)
-            *pActual_size = cur_size;
-      }
-
-      return p_new;
-   }
-
-   static crn_realloc_func    g_pRealloc = crnlib_nofree_realloc;
-   static crn_msize_func      g_pMSize   = crnlib_nofree_msize;
-#else
 static crn_realloc_func g_pRealloc = crnlib_default_realloc;
 static crn_msize_func g_pMSize = crnlib_default_msize;
-#endif
 static void* g_pUser_data;
 
 void crnlib_mem_error(const char* p_msg) {
diff --git a/crnlib/crn_miniz.cpp b/crnlib/crn_miniz.cpp
index 2a246ba..ca46fd7 100644
--- a/crnlib/crn_miniz.cpp
+++ b/crnlib/crn_miniz.cpp
@@ -2310,7 +2310,7 @@ void* tdefl_write_image_to_png_file_in_memory(const void* pImage, int w, int h,
   *pLen_out = out_buf.m_size - 41;
   {
     mz_uint8 pnghdr[41] = {0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
-                           0, 0, (mz_uint8)(w >> 8), (mz_uint8)w, 0, 0, (mz_uint8)(h >> 8), (mz_uint8)h, 8, "\0\0\04\02\06"[num_chans], 0, 0, 0, 0, 0, 0, 0,
+                           0, 0, (mz_uint8)(w >> 8), (mz_uint8)w, 0, 0, (mz_uint8)(h >> 8), (mz_uint8)h, 8, (mz_uint8)"\0\0\04\02\06"[num_chans], 0, 0, 0, 0, 0, 0, 0,
                            (mz_uint8)(*pLen_out >> 24), (mz_uint8)(*pLen_out >> 16), (mz_uint8)(*pLen_out >> 8), (mz_uint8)*pLen_out, 0x49, 0x44, 0x41, 0x54};
     c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17);
     for (i = 0; i < 4; ++i, c <<= 8)
diff --git a/crnlib/crn_mipmapped_texture.cpp b/crnlib/crn_mipmapped_texture.cpp
index 2986441..d7e0770 100644
--- a/crnlib/crn_mipmapped_texture.cpp
+++ b/crnlib/crn_mipmapped_texture.cpp
@@ -169,10 +169,7 @@ bool mip_level::unpack_from_dxt(bool uncook) {
     return false;
 
   image_u8* pNew_img = crnlib_new<image_u8>();
-  image_u8* pImg = get_unpacked_image(*pNew_img, uncook ? cUnpackFlagUncook : 0);
-  pImg;
-
-  CRNLIB_ASSERT(pImg == pNew_img);
+  CRNLIB_ASSERT(get_unpacked_image(*pNew_img, uncook ? cUnpackFlagUncook : 0) == pNew_img);
 
   assign(pNew_img, PIXEL_FMT_INVALID, m_orient_flags);
   return true;
@@ -2590,7 +2587,7 @@ bool mipmapped_texture::read_from_stream(data_stream_serializer& serializer, tex
   bool success = false;
 
   if (!texture_file_types::supports_mipmaps(file_format)) {
-    success = read_regular_image(serializer, file_format);
+    success = read_regular_image(serializer);
   } else {
     switch (file_format) {
       case texture_file_types::cFormatDDS: {
@@ -2623,9 +2620,7 @@ bool mipmapped_texture::read_from_stream(data_stream_serializer& serializer, tex
   return success;
 }
 
-bool mipmapped_texture::read_regular_image(data_stream_serializer& serializer, texture_file_types::format file_format) {
-  file_format;
-
+bool mipmapped_texture::read_regular_image(data_stream_serializer& serializer) {
   image_u8* pImg = crnlib_new<image_u8>();
   bool status = image_utils::read_from_stream(*pImg, serializer, 0);
   if (!status) {
diff --git a/crnlib/crn_mipmapped_texture.h b/crnlib/crn_mipmapped_texture.h
index af44902..837a206 100644
--- a/crnlib/crn_mipmapped_texture.h
+++ b/crnlib/crn_mipmapped_texture.h
@@ -321,7 +321,7 @@ class mipmapped_texture {
   inline void set_last_error(const char* p) const { m_last_error = p; }
 
   void free_all_mips();
-  bool read_regular_image(data_stream_serializer& serializer, texture_file_types::format file_format);
+  bool read_regular_image(data_stream_serializer& serializer);
   bool write_regular_image(const char* pFilename, uint32 image_write_flags);
   bool read_dds_internal(data_stream_serializer& serializer);
   void print_crn_comp_params(const crn_comp_params& p);
diff --git a/crnlib/crn_qdxt1.cpp b/crnlib/crn_qdxt1.cpp
index 836f325..ebbabbd 100644
--- a/crnlib/crn_qdxt1.cpp
+++ b/crnlib/crn_qdxt1.cpp
@@ -383,8 +383,7 @@ bool qdxt1::update_progress(uint value, uint max_value) {
   return true;
 }
 
-void qdxt1::pack_endpoints_task(uint64 data, void* pData_ptr) {
-  pData_ptr;
+void qdxt1::pack_endpoints_task(uint64 data, void*) {
   const uint thread_index = static_cast<uint>(data);
 
   crnlib::vector<color_quad_u8> cluster_pixels;
diff --git a/crnlib/crn_qdxt5.cpp b/crnlib/crn_qdxt5.cpp
index 28a4000..69d0224 100644
--- a/crnlib/crn_qdxt5.cpp
+++ b/crnlib/crn_qdxt5.cpp
@@ -358,8 +358,7 @@ bool qdxt5::update_progress(uint value, uint max_value) {
   return true;
 }
 
-void qdxt5::pack_endpoints_task(uint64 data, void* pData_ptr) {
-  pData_ptr;
+void qdxt5::pack_endpoints_task(uint64 data, void*) {
   const uint thread_index = static_cast<uint>(data);
 
   crnlib::vector<color_quad_u8> cluster_pixels;
diff --git a/crnlib/crn_resample_filters.cpp b/crnlib/crn_resample_filters.cpp
index 8c52cb0..6b4ef40 100644
--- a/crnlib/crn_resample_filters.cpp
+++ b/crnlib/crn_resample_filters.cpp
@@ -4,7 +4,9 @@
 #include "crn_resample_filters.h"
 
 namespace crnlib {
+#ifndef M_PI
 #define M_PI 3.14159265358979323846
+#endif
 
 // To add your own filter, insert the new function below and update the filter table.
 // There is no need to make the filter function particularly fast, because it's
diff --git a/crnlib/crn_resampler.cpp b/crnlib/crn_resampler.cpp
index f198d32..d183475 100644
--- a/crnlib/crn_resampler.cpp
+++ b/crnlib/crn_resampler.cpp
@@ -8,7 +8,7 @@ namespace crnlib {
 #define resampler_assert CRNLIB_ASSERT
 
 static inline int resampler_range_check(int v, int h) {
-  h;
+  (void)h;
   resampler_assert((v >= 0) && (v < h));
   return v;
 }
diff --git a/crnlib/crn_rg_etc1.cpp b/crnlib/crn_rg_etc1.cpp
index 77b9ef1..9afe5c5 100644
--- a/crnlib/crn_rg_etc1.cpp
+++ b/crnlib/crn_rg_etc1.cpp
@@ -1457,37 +1457,34 @@ bool unpack_etc2_color(const void* pBlock, unsigned int* pDst_pixels_rgba, bool
   color_quad_u8* pDst = reinterpret_cast<color_quad_u8*>(pDst_pixels_rgba);
   const etc1_block& block = *static_cast<const etc1_block*>(pBlock);
   const uint8* B = block.m_bytes;
-  const bool rOverflow = (int8(B[0] << 5) >> 5) + (B[0] >> 3) & 0x20;
-  const bool gOverflow = (int8(B[1] << 5) >> 5) + (B[1] >> 3) & 0x20;
+  const bool rOverflow = ((int8(B[0] << 5) >> 5) + (B[0] >> 3)) & 0x20;
+  const bool gOverflow = ((int8(B[1] << 5) >> 5) + (B[1] >> 3)) & 0x20;
 
   if (rOverflow || gOverflow) {
     color_quad_u8 block_colors[4];
+    uint8 unpacked[3];
     if (rOverflow) {
-      uint8 unpacked[3] = {
-        B[0] & 0x3 | B[0] >> 1 & 0xC | B[2] & 0xF0,
-        B[1] >> 4 | B[2] << 4,
-        B[1] & 0xF | B[3] & 0xF0,
-      };
-      uint8 delta = g_etc2_modifier_table[B[3] & 1 | B[3] >> 1 & 6];
+      unpacked[0] = (B[0] & 0x3) | (B[0] >> 1 & 0xC) | (B[2] & 0xF0);
+      unpacked[1] = B[1] >> 4 | B[2] << 4;
+      unpacked[2] = (B[1] & 0xF) | (B[3] & 0xF0);
+      uint8 delta = g_etc2_modifier_table[(B[3] & 1) | (B[3] >> 1 & 6)];
       for (uint c = 0; c < 3; c++) {
-        block_colors[2][c] = unpacked[c] << 4 | unpacked[c] & 0xF;
-        block_colors[1][c] = unpacked[c] >> 4 | unpacked[c] & 0xF0;
+        block_colors[2][c] = unpacked[c] << 4 | (unpacked[c] & 0xF);
+        block_colors[1][c] = unpacked[c] >> 4 | (unpacked[c] & 0xF0);
         block_colors[0][c] = math::maximum(0, block_colors[1][c] - delta);
         block_colors[3][c] = math::minimum(255, block_colors[1][c] + delta);
       }
     } else {
-      uint8 unpacked[3] = {
-        B[0] >> 3 & 0xF | B[2] << 1 & 0xF0,
-        B[1] >> 4 & 0x1 | B[0] << 1 & 0xE | B[3] >> 3 & 0x10 | B[2] << 5,
-        B[2] >> 7 | B[1] << 1 & 0x6 | B[1] & 0x8 | B[3] << 1 & 0xF0,
-      };
-      uint8 modifier = B[3] & 4 | B[3] << 1 & 2 | 1;
+      unpacked[0] = (B[0] >> 3 & 0xF) | (B[2] << 1 & 0xF0);
+      unpacked[1] = (B[1] >> 4 & 0x1) | (B[0] << 1 & 0xE) | (B[3] >> 3 & 0x10) | B[2] << 5;
+      unpacked[2] = B[2] >> 7 | (B[1] << 1 & 0x6) | (B[1] & 0x8) | (B[3] << 1 & 0xF0);
+      uint8 modifier = (B[3] & 4) | (B[3] << 1 & 2) | 1;
       for (int d = 0, c = 0; !d && c < 3; c++, modifier &= d < 0 ? 6 : 7)
         d = (unpacked[c] & 0xF) - (unpacked[c] >> 4);
       uint8 delta = g_etc2_modifier_table[modifier];
       for (uint c = 0; c < 3; c++) {
-        uint8 c0 = unpacked[c] << 4 | unpacked[c] & 0xF;
-        uint8 c1 = unpacked[c] >> 4 | unpacked[c] & 0xF0;
+        uint8 c0 = unpacked[c] << 4 | (unpacked[c] & 0xF);
+        uint8 c1 = unpacked[c] >> 4 | (unpacked[c] & 0xF0);
         block_colors[0][c] = math::maximum(0, c1 - delta);
         block_colors[1][c] = math::minimum(255, c1 + delta);
         block_colors[2][c] = math::minimum(255, c0 + delta);
@@ -1503,15 +1500,15 @@ bool unpack_etc2_color(const void* pBlock, unsigned int* pDst_pixels_rgba, bool
     }
   } else {
     int16 base[3], dj[3], di[3], color[3];
-    base[0] = B[0] << 1 & 0xFC | B[0] >> 5 & 3;
-    base[1] = B[0] << 7 & 0x80 | B[1] & 0x7E | B[0] & 1;
-    base[2] = B[1] << 7 & 0x80 | B[2] << 2 & 0x60 | B[2] << 3 & 0x18 | B[3] >> 5 & 4 | B[1] << 1 & 2 | B[2] >> 4 & 1;
-    di[0] = (B[5] << 5 & 0xE0 | B[6] >> 3 & 0x1C | B[5] >> 1 & 0x3) - base[0];
-    di[1] = (B[6] << 3 & 0xF8 | B[7] >> 5 & 0x6 | B[6] >> 4 & 0x1) - base[1];
-    di[2] = (B[7] << 2 & 0xFC | B[7] >> 4 & 0x3) - base[2];
-    dj[0] = (B[3] << 1 & 0xF8 | B[3] << 2 & 0x4 | B[3] >> 5 & 0x3) - base[0];
-    dj[1] = (B[4] & 0xFE | B[4] >> 7) - base[1];
-    dj[2] = (B[4] << 7 & 0x80 | B[5] >> 1 & 0x7C | B[4] << 1 & 0x2 | B[5] >> 7) - base[2];
+    base[0] = (B[0] << 1 & 0xFC) | (B[0] >> 5 & 3);
+    base[1] = (B[0] << 7 & 0x80) | (B[1] & 0x7E) | (B[0] & 1);
+    base[2] = (B[1] << 7 & 0x80) | (B[2] << 2 & 0x60) | (B[2] << 3 & 0x18) | (B[3] >> 5 & 4) | (B[1] << 1 & 2) | (B[2] >> 4 & 1);
+    di[0] = ((B[5] << 5 & 0xE0) | (B[6] >> 3 & 0x1C) | (B[5] >> 1 & 0x3)) - base[0];
+    di[1] = ((B[6] << 3 & 0xF8) | (B[7] >> 5 & 0x6) | (B[6] >> 4 & 0x1)) - base[1];
+    di[2] = ((B[7] << 2 & 0xFC) | (B[7] >> 4 & 0x3)) - base[2];
+    dj[0] = ((B[3] << 1 & 0xF8) | (B[3] << 2 & 0x4) | (B[3] >> 5 & 0x3)) - base[0];
+    dj[1] = ((B[4] & 0xFE) | B[4] >> 7) - base[1];
+    dj[2] = ((B[4] << 7 & 0x80) | (B[5] >> 1 & 0x7C) | (B[4] << 1 & 0x2) | B[5] >> 7) - base[2];
     for (uint c = 0; c < 3; c++)
       base[c] = (base[c] << 2) + 2;
     for (uint i = 0; i < 4; i++) {
@@ -1539,7 +1536,7 @@ bool unpack_etc2_alpha(const void* pBlock, unsigned int* pDst_pixels_rgba, int c
     for (uint d = d0, j = 0; j < 4; j++, pDst++, d += 12) {
       int byte_offset = 2 + (d >> 3);
       int bit_offset = d & 7;
-      int s = B[byte_offset] >> 8 - bit_offset & 7;
+      int s = B[byte_offset] >> (8 - bit_offset) & 7;
       if (bit_offset < 3)
         s |= B[byte_offset - 1] << bit_offset & 7;
       pDst->c[comp_index] = values[s];
@@ -2045,7 +2042,7 @@ bool etc1_optimizer::evaluate_solution_fast(const etc1_solution_coordinates& coo
     const color_quad_u8* pSrc_pixels = m_pParams->m_pSrc_pixels;
     if ((m_pSorted_luma[n - 1] * 2) < block_inten_midpoints[0]) {
       if (block_inten[0] > m_pSorted_luma[n - 1]) {
-        const uint min_error = labs(block_inten[0] - m_pSorted_luma[n - 1]);
+        const uint min_error = block_inten[0] - m_pSorted_luma[n - 1];
         if (min_error >= trial_solution.m_error)
           continue;
       }
@@ -2056,7 +2053,7 @@ bool etc1_optimizer::evaluate_solution_fast(const etc1_solution_coordinates& coo
         total_error += block_colors[0].squared_distance_rgb(pSrc_pixels[c]);
     } else if ((m_pSorted_luma[0] * 2) >= block_inten_midpoints[2]) {
       if (m_pSorted_luma[0] > block_inten[3]) {
-        const uint min_error = labs(m_pSorted_luma[0] - block_inten[3]);
+        const uint min_error = m_pSorted_luma[0] - block_inten[3];
         if (min_error >= trial_solution.m_error)
           continue;
       }
@@ -2109,9 +2106,7 @@ bool etc1_optimizer::evaluate_solution_fast(const etc1_solution_coordinates& coo
 }
 
 static uint etc1_decode_value(uint diff, uint inten, uint selector, uint packed_c) {
-  const uint limit = diff ? 32 : 16;
-  limit;
-  RG_ETC1_ASSERT((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < limit));
+  RG_ETC1_ASSERT((diff < 2) && (inten < 8) && (selector < 4) && (packed_c < (diff ? 32 : 16)));
   int c;
   if (diff)
     c = (packed_c >> 2) | (packed_c << 3);
@@ -2134,7 +2129,7 @@ void pack_etc1_block_init() {
     for (uint inten = 0; inten < 8; inten++) {
       for (uint selector = 0; selector < 4; selector++) {
         const uint inverse_table_index = diff + (inten << 1) + (selector << 4);
-        for (uint color = 0; color < 256; color++) {
+        for (int color = 0; color < 256; color++) {
           uint best_error = cUINT32_MAX, best_packed_c = 0;
           for (uint packed_c = 0; packed_c < limit; packed_c++) {
             int v = etc1_decode_value(diff, inten, selector, packed_c);
@@ -2165,8 +2160,7 @@ void pack_etc1_block_init() {
 
 // Packs solid color blocks efficiently using a set of small precomputed tables.
 // For random 888 inputs, MSE results are better than Erricson's ETC1 packer in "slow" mode ~9.5% of the time, is slightly worse only ~.01% of the time, and is equal the rest of the time.
-static uint64 pack_etc1_block_solid_color(etc1_block& block, const uint8* pColor, etc1_pack_params& pack_params) {
-  pack_params;
+static uint64 pack_etc1_block_solid_color(etc1_block& block, const uint8* pColor) {
   RG_ETC1_ASSERT(g_etc1_inverse_lookup[0][255]);
 
   static uint s_next_comp[4] = {1, 2, 0, 1};
@@ -2245,12 +2239,10 @@ found_perfect_match:
 static uint pack_etc1_block_solid_color_constrained(
     etc1_optimizer::results& results,
     uint num_colors, const uint8* pColor,
-    etc1_pack_params& pack_params,
     bool use_diff,
     const color_quad_u8* pBase_color5_unscaled) {
   RG_ETC1_ASSERT(g_etc1_inverse_lookup[0][255]);
 
-  pack_params;
   static uint s_next_comp[4] = {1, 2, 0, 1};
 
   uint best_error = cUINT32_MAX, best_i = 0;
@@ -2404,7 +2396,7 @@ unsigned int pack_etc1_block(void* pETC1_block, const unsigned int* pSrc_pixels_
     if (pSrc_pixels[r].m_u32 != first_pixel_u32)
       break;
   if (!r)
-    return static_cast<unsigned int>(16 * pack_etc1_block_solid_color(dst_block, &pSrc_pixels[0].r, pack_params));
+    return static_cast<unsigned int>(16 * pack_etc1_block_solid_color(dst_block, &pSrc_pixels[0].r));
 
   color_quad_u8 dithered_pixels[16];
   if (pack_params.m_dithering) {
@@ -2465,7 +2457,7 @@ unsigned int pack_etc1_block(void* pETC1_block, const unsigned int* pSrc_pixels_
             if (subblock_pixels[r].m_u32 != subblock_pixel0_u32)
               break;
           if (!r) {
-            pack_etc1_block_solid_color_constrained(results[2], 8, &subblock_pixels[0].r, pack_params, !use_color4, (subblock && !use_color4) ? &results[0].m_block_color_unscaled : NULL);
+            pack_etc1_block_solid_color_constrained(results[2], 8, &subblock_pixels[0].r, !use_color4, (subblock && !use_color4) ? &results[0].m_block_color_unscaled : NULL);
           }
         }
 
@@ -2654,7 +2646,7 @@ unsigned int pack_etc2_alpha(void* pBlock, const unsigned int* pSrc_pixels_rgba,
   for (int modifier_index = 0; modifier_index < 16; modifier_index++) {
     const int* modifier = g_etc2a_modifier_table[modifier_index];
     int multiplier = math::clamp<int>((results.m_first_endpoint - results.m_second_endpoint + modifier[7] + (modifier[7] >> 1)) / (modifier[7] << 1), 1, 15);
-    uint8 data[8] = {base_codeword, multiplier << 4 | modifier_index}, values[8];
+    uint8 data[8] = {(uint8)base_codeword, (uint8)(multiplier << 4 | modifier_index)}, values[8];
     for (int i = 0; i < 8; i++)
       values[i] = math::clamp<int>(base_codeword + modifier[i] * multiplier, 0, 255);
     uint error = 0;
@@ -2673,7 +2665,7 @@ unsigned int pack_etc2_alpha(void* pBlock, const unsigned int* pSrc_pixels_rgba,
           }
         }
         error += best_delta * best_delta;
-        data[byte_offset] |= best_s << 8 - bit_offset;
+        data[byte_offset] |= best_s << (8 - bit_offset);
         if (bit_offset < 3)
           data[byte_offset - 1] |= best_s >> bit_offset;
       }
diff --git a/crnlib/crn_ryg_dxt.cpp b/crnlib/crn_ryg_dxt.cpp
index 4d40710..4841eec 100644
--- a/crnlib/crn_ryg_dxt.cpp
+++ b/crnlib/crn_ryg_dxt.cpp
@@ -462,8 +462,7 @@ static void CompressColorBlock(sU8* dest, const sU32* src, sInt quality) {
 }
 
 // Alpha block compression (this is easy for a change)
-static void CompressAlphaBlock(sU8* dest, const sU32* src, sInt quality) {
-  quality;
+static void CompressAlphaBlock(sU8* dest, const sU32* src) {
   const Pixel* block = (const Pixel*)src;
 
   // find min/max color
@@ -540,7 +539,7 @@ void sCompressDXTBlock(sU8* dest, const sU32* src, sBool alpha, sInt quality) {
 
   // if alpha specified, compress alpha as well
   if (alpha) {
-    CompressAlphaBlock(dest, src, quality);
+    CompressAlphaBlock(dest, src);
     dest += 8;
   }
 
@@ -548,10 +547,10 @@ void sCompressDXTBlock(sU8* dest, const sU32* src, sBool alpha, sInt quality) {
   CompressColorBlock(dest, src, quality);
 }
 
-void sCompressDXT5ABlock(sU8* dest, const sU32* src, sInt quality) {
+void sCompressDXT5ABlock(sU8* dest, const sU32* src) {
   CRNLIB_ASSERT(Expand5[1]);
 
-  CompressAlphaBlock(dest, src, quality);
+  CompressAlphaBlock(dest, src);
 }
 
 }  // namespace ryg_dxt
diff --git a/crnlib/crn_ryg_dxt.hpp b/crnlib/crn_ryg_dxt.hpp
index ab6b887..b2469e0 100644
--- a/crnlib/crn_ryg_dxt.hpp
+++ b/crnlib/crn_ryg_dxt.hpp
@@ -22,6 +22,6 @@ void sInitDXT();
 // quality: 0=fastest (no dither), 1=medium (dither)
 void sCompressDXTBlock(sU8* dest, const sU32* src, sBool alpha, sInt quality);
 
-void sCompressDXT5ABlock(sU8* dest, const sU32* src, sInt quality);
+void sCompressDXT5ABlock(sU8* dest, const sU32* src);
 
 }  // namespace ryg_dxt
diff --git a/crnlib/crn_stb_image.cpp b/crnlib/crn_stb_image.cpp
index e2ba450..1e999cb 100644
--- a/crnlib/crn_stb_image.cpp
+++ b/crnlib/crn_stb_image.cpp
@@ -743,8 +743,7 @@ static uint32 get32le(stbi* s) {
 static void getn(stbi* s, stbi_uc* buffer, int n) {
 #ifndef STBI_NO_STDIO
   if (s->img_file) {
-    size_t nr = fread(buffer, 1, n, s->img_file);
-    nr;
+    fread(buffer, 1, n, s->img_file);
     return;
   }
 #endif
@@ -1712,13 +1711,11 @@ typedef uint8* (*resample_row_func)(uint8* out, uint8* in0, uint8* in1,
 
 #define div4(x) ((uint8)((x) >> 2))
 
-static uint8* resample_row_1(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) {
-  out, in_far, w, hs;
+static uint8* resample_row_1(uint8*, uint8* in_near, uint8*, int, int) {
   return in_near;
 }
 
-static uint8* resample_row_v_2(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) {
-  hs;
+static uint8* resample_row_v_2(uint8* out, uint8* in_near, uint8* in_far, int w, int) {
   // need to generate two samples vertically for every one in input
   int i;
   for (i = 0; i < w; ++i)
@@ -1726,8 +1723,7 @@ static uint8* resample_row_v_2(uint8* out, uint8* in_near, uint8* in_far, int w,
   return out;
 }
 
-static uint8* resample_row_h_2(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) {
-  hs, in_far;
+static uint8* resample_row_h_2(uint8* out, uint8* in_near, uint8*, int w, int) {
   // need to generate two samples horizontally for every one in input
   int i;
   uint8* input = in_near;
@@ -1751,8 +1747,7 @@ static uint8* resample_row_h_2(uint8* out, uint8* in_near, uint8* in_far, int w,
 
 #define div16(x) ((uint8)((x) >> 4))
 
-static uint8* resample_row_hv_2(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) {
-  hs;
+static uint8* resample_row_hv_2(uint8* out, uint8* in_near, uint8* in_far, int w, int) {
   // need to generate 2x2 samples for every one in input
   int i, t0, t1;
   if (w == 1) {
@@ -1772,8 +1767,7 @@ static uint8* resample_row_hv_2(uint8* out, uint8* in_near, uint8* in_far, int w
   return out;
 }
 
-static uint8* resample_row_generic(uint8* out, uint8* in_near, uint8* in_far, int w, int hs) {
-  in_far;
+static uint8* resample_row_generic(uint8* out, uint8* in_near, uint8*, int w, int hs) {
   // resample with nearest-neighbor
   int i, j;
   for (i = 0; i < w; ++i)
@@ -2723,8 +2717,7 @@ static int compute_transparency(png* z, uint8 tc[3], int out_n) {
   return 1;
 }
 
-static int expand_palette(png* a, uint8* palette, int len, int pal_img_n) {
-  len;
+static int expand_palette(png* a, uint8* palette, int pal_img_n) {
   uint32 i, pixel_count = a->s.img_x * a->s.img_y;
   uint8 *p, *temp_out, *orig = a->out;
 
@@ -2926,7 +2919,7 @@ static int parse_png_file(png* z, int scan, int req_comp) {
           s->img_out_n = pal_img_n;
           if (req_comp >= 3)
             s->img_out_n = req_comp;
-          if (!expand_palette(z, palette, pal_len, s->img_out_n))
+          if (!expand_palette(z, palette, s->img_out_n))
             return 0;
         }
         stb_free(z->expanded);
@@ -4020,7 +4013,7 @@ static float* hdr_load(stbi* s, int* x, int* y, int* comp, int req_comp) {
       if (c1 != 2 || c2 != 2 || (len & 0x80)) {
         // not run-length encoded, so we have to actually use THIS data as a decoded
         // pixel (note this can't be a valid pixel--one of RGB must be >= 128)
-        stbi_uc rgbe[4] = {c1, c2, len, get8(s)};
+        stbi_uc rgbe[4] = {(stbi_uc)c1, (stbi_uc)c2, (stbi_uc)len, (stbi_uc)get8(s)};
         hdr_convert(hdr_data, rgbe, req_comp);
         i = 1;
         j = 0;
diff --git a/crnlib/crn_symbol_codec.cpp b/crnlib/crn_symbol_codec.cpp
index 39fdece..8f92535 100644
--- a/crnlib/crn_symbol_codec.cpp
+++ b/crnlib/crn_symbol_codec.cpp
@@ -200,7 +200,7 @@ void adaptive_huffman_data_model::update() {
     status = prefix_coding::generate_decoder_tables(m_total_syms, &m_code_sizes[0], m_pDecode_tables, m_decoder_table_bits);
 
   CRNLIB_ASSERT(status);
-  status;
+  (void)status;
 
   m_update_cycle = (5 * m_update_cycle) >> 2;
   uint max_cycle = (m_total_syms + 6) << 3;  // this was << 2 - which is ~12% slower but compresses around .5% better
@@ -488,8 +488,7 @@ void adaptive_arith_data_model::clear() {
   m_probs.clear();
 }
 
-void adaptive_arith_data_model::init(bool encoding, uint total_syms) {
-  encoding;
+void adaptive_arith_data_model::init(bool, uint total_syms) {
   if (!total_syms) {
     clear();
     return;
diff --git a/crnlib/crn_symbol_codec.h b/crnlib/crn_symbol_codec.h
index 4789058..ea2dab2 100644
--- a/crnlib/crn_symbol_codec.h
+++ b/crnlib/crn_symbol_codec.h
@@ -174,7 +174,7 @@ class adaptive_arith_data_model {
   friend class symbol_codec;
 };
 
-#if (defined(_XBOX) || defined(_WIN64))
+#if defined(_WIN64)
 #define CRNLIB_SYMBOL_CODEC_USE_64_BIT_BUFFER 1
 #else
 #define CRNLIB_SYMBOL_CODEC_USE_64_BIT_BUFFER 0
@@ -311,9 +311,7 @@ class symbol_codec {
 
 #define CRNLIB_SYMBOL_CODEC_USE_MACROS 1
 
-#ifdef _XBOX
-#define CRNLIB_READ_BIG_ENDIAN_UINT32(p) *reinterpret_cast<const uint32*>(p)
-#elif defined(_MSC_VER)
+#if defined(_MSC_VER)
 #define CRNLIB_READ_BIG_ENDIAN_UINT32(p) _byteswap_ulong(*reinterpret_cast<const uint32*>(p))
 #else
 #define CRNLIB_READ_BIG_ENDIAN_UINT32(p) utils::swap32(*reinterpret_cast<const uint32*>(p))
diff --git a/crnlib/crn_threaded_clusterizer.h b/crnlib/crn_threaded_clusterizer.h
index 4db1d28..cd2acf4 100644
--- a/crnlib/crn_threaded_clusterizer.h
+++ b/crnlib/crn_threaded_clusterizer.h
@@ -273,9 +273,7 @@ class threaded_clusterizer {
     compute_division(axis, centroid, vecs, indices, left_indices, right_indices);
   }
 
-  static bool generate_codebook_dummy_progress_callback(uint percentage_completed, void* pData) {
-    percentage_completed;
-
+  static bool generate_codebook_dummy_progress_callback(uint, void* pData) {
     if (static_cast<threaded_clusterizer*>(pData)->m_canceled)
       return false;
 
diff --git a/crnlib/crn_threaded_resampler.cpp b/crnlib/crn_threaded_resampler.cpp
index 1b88c6d..b646d6d 100644
--- a/crnlib/crn_threaded_resampler.cpp
+++ b/crnlib/crn_threaded_resampler.cpp
@@ -36,8 +36,7 @@ void threaded_resampler::free_contrib_lists() {
   }
 }
 
-void threaded_resampler::resample_x_task(uint64 data, void* pData_ptr) {
-  pData_ptr;
+void threaded_resampler::resample_x_task(uint64 data, void*) {
   const uint thread_index = (uint)data;
 
   for (uint src_y = 0; src_y < m_pParams->m_src_height; src_y++) {
@@ -138,9 +137,7 @@ void threaded_resampler::resample_x_task(uint64 data, void* pData_ptr) {
   }
 }
 
-void threaded_resampler::resample_y_task(uint64 data, void* pData_ptr) {
-  pData_ptr;
-
+void threaded_resampler::resample_y_task(uint64 data, void*) {
   const uint thread_index = (uint)data;
 
   crnlib::vector<vec4F> tmp(m_pParams->m_dst_width);
diff --git a/crnlib/crn_timer.h b/crnlib/crn_timer.h
index 66979e6..e5b8b82 100644
--- a/crnlib/crn_timer.h
+++ b/crnlib/crn_timer.h
@@ -46,7 +46,7 @@ class timed_scope {
   timer m_tm;
 
  public:
-  inline timed_scope(char* pName = "timed_scope")
+  inline timed_scope(const char* pName = "timed_scope")
       : m_pName(pName) { m_tm.start(); }
 
   inline double get_elapsed_secs() const { return m_tm.get_elapsed_secs(); }
diff --git a/crnlib/crn_traits.h b/crnlib/crn_traits.h
index 233e1b5..60f5b68 100644
--- a/crnlib/crn_traits.h
+++ b/crnlib/crn_traits.h
@@ -63,8 +63,8 @@ struct scalar_type<T*> {
   static inline void construct(T** p) { memset(p, 0, sizeof(T*)); }
   static inline void construct(T** p, T* init) { *p = init; }
   static inline void construct_array(T** p, uint n) { memset(p, 0, sizeof(T*) * n); }
-  static inline void destruct(T** p) { p; }
-  static inline void destruct_array(T** p, uint n) { p, n; }
+  static inline void destruct(T**) {}
+  static inline void destruct_array(T**, uint) {}
 };
 
 #define CRNLIB_DEFINE_BUILT_IN_TYPE(X)                                                 \
@@ -74,8 +74,8 @@ struct scalar_type<T*> {
     static inline void construct(X* p) { memset(p, 0, sizeof(X)); }                    \
     static inline void construct(X* p, const X& init) { memcpy(p, &init, sizeof(X)); } \
     static inline void construct_array(X* p, uint n) { memset(p, 0, sizeof(X) * n); }  \
-    static inline void destruct(X* p) { p; }                                           \
-    static inline void destruct_array(X* p, uint n) { p, n; }                          \
+    static inline void destruct(X*) {}                                                 \
+    static inline void destruct_array(X*, uint) {}                                     \
   };
 
 CRNLIB_DEFINE_BUILT_IN_TYPE(bool)
diff --git a/crnlib/crn_tree_clusterizer.h b/crnlib/crn_tree_clusterizer.h
index 617cdbc..7c88769 100644
--- a/crnlib/crn_tree_clusterizer.h
+++ b/crnlib/crn_tree_clusterizer.h
@@ -377,10 +377,7 @@ class tree_clusterizer {
       new_right_child *= (1.0f / right_weight);
 
       left_child = new_left_child;
-      left_weight = left_weight;
-
       right_child = new_right_child;
-      right_weight = right_weight;
 
       float total_variance = left_variance + right_variance;
       if (total_variance < .00001f)
diff --git a/crnlib/crn_vec.h b/crnlib/crn_vec.h
index 03f182f..c4199bc 100644
--- a/crnlib/crn_vec.h
+++ b/crnlib/crn_vec.h
@@ -748,9 +748,9 @@ struct scalar_type<vec<N, T> > {
   enum { cFlag = true };
   static inline void construct(vec<N, T>* p) {}
   static inline void construct(vec<N, T>* p, const vec<N, T>& init) { memcpy(p, &init, sizeof(vec<N, T>)); }
-  static inline void construct_array(vec<N, T>* p, uint n) { p, n; }
-  static inline void destruct(vec<N, T>* p) { p; }
-  static inline void destruct_array(vec<N, T>* p, uint n) { p, n; }
+  static inline void construct_array(vec<N, T>*, uint) {}
+  static inline void destruct(vec<N, T>*) {}
+  static inline void destruct_array(vec<N, T>*, uint) {}
 };
 
 }  // namespace crnlib
diff --git a/crnlib/crnlib.cpp b/crnlib/crnlib.cpp
index 52e5d9c..b4c3d56 100644
--- a/crnlib/crnlib.cpp
+++ b/crnlib/crnlib.cpp
@@ -14,13 +14,11 @@
 #include "crn_rg_etc1.h"
 
 namespace crnlib {
-static void* realloc_func(void* p, size_t size, size_t* pActual_size, bool movable, void* pUser_data) {
-  pUser_data;
+static void* realloc_func(void* p, size_t size, size_t* pActual_size, bool movable, void*) {
   return crnlib_realloc(p, size, pActual_size, movable);
 }
 
-static size_t msize_func(void* p, void* pUser_data) {
-  pUser_data;
+static size_t msize_func(void* p, void*) {
   return crnlib_msize(p);
 }
 
diff --git a/inc/crn_decomp.h b/inc/crn_decomp.h
index 9c3fdba..1f43e0c 100644
--- a/inc/crn_decomp.h
+++ b/inc/crn_decomp.h
@@ -64,16 +64,6 @@ enum eClear { cClear };
 
 const uint32 cIntBits = 32U;
 
-#ifdef _WIN64
-typedef uint64 ptr_bits;
-#else
-#ifdef __x86_64__
-typedef uint64 ptr_bits;
-#else
-typedef uint32 ptr_bits;
-#endif
-#endif
-
 template <typename T>
 struct int_traits {
   enum { cMin = crnd::cINT32_MIN,
@@ -190,7 +180,6 @@ void construct_array(T* p, uint32 n, const U& init) {
 
 template <typename T>
 inline void destruct(T* p) {
-  p;
   p->~T();
 }
 
@@ -223,8 +212,8 @@ struct scalar_type<T*> {
   static inline void construct(T** p) { memset(p, 0, sizeof(T*)); }
   static inline void construct(T** p, T* init) { *p = init; }
   static inline void construct_array(T** p, uint32 n) { memset(p, 0, sizeof(T*) * n); }
-  static inline void destruct(T** p) { p; }
-  static inline void destruct_array(T** p, uint32 n) { p, n; }
+  static inline void destruct(T**) {}
+  static inline void destruct_array(T**, uint32) {}
 };
 
 #define CRND_DEFINE_BUILT_IN_TYPE(X)                                                    \
@@ -234,8 +223,8 @@ struct scalar_type<T*> {
     static inline void construct(X* p) { memset(p, 0, sizeof(X)); }                     \
     static inline void construct(X* p, const X& init) { memcpy(p, &init, sizeof(X)); }  \
     static inline void construct_array(X* p, uint32 n) { memset(p, 0, sizeof(X) * n); } \
-    static inline void destruct(X* p) { p; }                                            \
-    static inline void destruct_array(X* p, uint32 n) { p, n; }                         \
+    static inline void destruct(X*) {}                                                  \
+    static inline void destruct_array(X*, uint32) {}                                    \
   };
 
 CRND_DEFINE_BUILT_IN_TYPE(bool)
@@ -355,9 +344,7 @@ template <typename T>
 inline void crnd_delete_array(T* p) {
   if (p) {
     const uint32 num = reinterpret_cast<uint32*>(p)[-1];
-    const uint32 num_check = reinterpret_cast<uint32*>(p)[-2];
-    num_check;
-    CRND_ASSERT(num && (num == ~num_check));
+    CRND_ASSERT(num && (num == ~reinterpret_cast<uint32*>(p)[-2]));
 
     helpers::destruct_array(p, num);
 
@@ -830,7 +817,7 @@ extern void vector_test();
 
 // File: crnd_private.h
 namespace crnd {
-const crn_header* crnd_get_header(crn_header& header, const void* pData, uint32 data_size);
+const crn_header* crnd_get_header(const void* pData, uint32 data_size);
 
 }  // namespace crnd
 
@@ -1917,7 +1904,7 @@ void crnd_debug_break() {
 }
 
 void crnd_output_debug_string(const char* p) {
-  p;
+  (void)p;
 #ifdef CRND_DEVEL
   OutputDebugStringA(p);
 #endif
@@ -1929,9 +1916,7 @@ void crnd_output_debug_string(const char* p) {
 namespace crnd {
 const uint32 MAX_POSSIBLE_BLOCK_SIZE = 0x7FFF0000U;
 
-static void* crnd_default_realloc(void* p, size_t size, size_t* pActual_size, bool movable, void* pUser_data) {
-  pUser_data;
-
+static void* crnd_default_realloc(void* p, size_t size, size_t* pActual_size, bool movable, void*) {
   void* p_new;
 
   if (!p) {
@@ -2029,13 +2014,13 @@ void* crnd_malloc(size_t size, size_t* pActual_size) {
     return NULL;
   }
 
-  CRND_ASSERT(((uint32)p_new & (CRND_MIN_ALLOC_ALIGNMENT - 1)) == 0);
+  CRND_ASSERT(((uint32) reinterpret_cast<uintptr_t>(p_new) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) == 0);
 
   return p_new;
 }
 
 void* crnd_realloc(void* p, size_t size, size_t* pActual_size, bool movable) {
-  if ((uint32) reinterpret_cast<ptr_bits>(p) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) {
+  if ((uint32) reinterpret_cast<uintptr_t>(p) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) {
     crnd_mem_error("crnd_realloc: bad ptr");
     return NULL;
   }
@@ -2051,7 +2036,7 @@ void* crnd_realloc(void* p, size_t size, size_t* pActual_size, bool movable) {
   if (pActual_size)
     *pActual_size = actual_size;
 
-  CRND_ASSERT(((uint32)p_new & (CRND_MIN_ALLOC_ALIGNMENT - 1)) == 0);
+  CRND_ASSERT(((uint32) reinterpret_cast<uintptr_t>(p_new) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) == 0);
 
   return p_new;
 }
@@ -2060,7 +2045,7 @@ void crnd_free(void* p) {
   if (!p)
     return;
 
-  if ((uint32) reinterpret_cast<ptr_bits>(p) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) {
+  if ((uint32) reinterpret_cast<uintptr_t>(p) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) {
     crnd_mem_error("crnd_free: bad ptr");
     return;
   }
@@ -2072,7 +2057,7 @@ size_t crnd_msize(void* p) {
   if (!p)
     return 0;
 
-  if ((uint32) reinterpret_cast<ptr_bits>(p) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) {
+  if ((uint32) reinterpret_cast<uintptr_t>(p) & (CRND_MIN_ALLOC_ALIGNMENT - 1)) {
     crnd_mem_error("crnd_msize: bad ptr");
     return 0;
   }
@@ -2180,9 +2165,7 @@ uint32 crnd_get_bytes_per_dxt_block(crn_format fmt) {
 }
 
 // TODO: tmp_header isn't used/This function is a helper to support old headers.
-const crn_header* crnd_get_header(crn_header& tmp_header, const void* pData, uint32 data_size) {
-  tmp_header;
-
+const crn_header* crnd_get_header(const void* pData, uint32 data_size) {
   if ((!pData) || (data_size < sizeof(crn_header)))
     return NULL;
 
@@ -2207,8 +2190,7 @@ bool crnd_validate_file(const void* pData, uint32 data_size, crn_file_info* pFil
   if ((!pData) || (data_size < cCRNHeaderMinSize))
     return false;
 
-  crn_header tmp_header;
-  const crn_header* pHeader = crnd_get_header(tmp_header, pData, data_size);
+  const crn_header* pHeader = crnd_get_header(pData, data_size);
   if (!pHeader)
     return false;
 
@@ -2268,8 +2250,7 @@ bool crnd_get_texture_info(const void* pData, uint32 data_size, crn_texture_info
   if (pInfo->m_struct_size != sizeof(crn_texture_info))
     return false;
 
-  crn_header tmp_header;
-  const crn_header* pHeader = crnd_get_header(tmp_header, pData, data_size);
+  const crn_header* pHeader = crnd_get_header(pData, data_size);
   if (!pHeader)
     return false;
 
@@ -2292,8 +2273,7 @@ bool crnd_get_level_info(const void* pData, uint32 data_size, uint32 level_index
   if (pLevel_info->m_struct_size != sizeof(crn_level_info))
     return false;
 
-  crn_header tmp_header;
-  const crn_header* pHeader = crnd_get_header(tmp_header, pData, data_size);
+  const crn_header* pHeader = crnd_get_header(pData, data_size);
   if (!pHeader)
     return false;
 
@@ -2321,8 +2301,7 @@ const void* crnd_get_level_data(const void* pData, uint32 data_size, uint32 leve
   if ((!pData) || (data_size < cCRNHeaderMinSize))
     return NULL;
 
-  crn_header tmp_header;
-  const crn_header* pHeader = crnd_get_header(tmp_header, pData, data_size);
+  const crn_header* pHeader = crnd_get_header(pData, data_size);
   if (!pHeader)
     return NULL;
 
@@ -2346,8 +2325,7 @@ uint32 crnd_get_segmented_file_size(const void* pData, uint32 data_size) {
   if ((!pData) || (data_size < cCRNHeaderMinSize))
     return false;
 
-  crn_header tmp_header;
-  const crn_header* pHeader = crnd_get_header(tmp_header, pData, data_size);
+  const crn_header* pHeader = crnd_get_header(pData, data_size);
   if (!pHeader)
     return false;
 
@@ -2366,8 +2344,7 @@ bool crnd_create_segmented_file(const void* pData, uint32 data_size, void* pBase
   if ((!pData) || (data_size < cCRNHeaderMinSize))
     return false;
 
-  crn_header tmp_header;
-  const crn_header* pHeader = crnd_get_header(tmp_header, pData, data_size);
+  const crn_header* pHeader = crnd_get_header(pData, data_size);
   if (!pHeader)
     return false;
 
@@ -2971,7 +2948,7 @@ class crn_unpacker {
   inline bool is_valid() const { return m_magic == cMagicValue; }
 
   bool init(const void* pData, uint32 data_size) {
-    m_pHeader = crnd_get_header(m_tmp_header, pData, data_size);
+    m_pHeader = crnd_get_header(pData, data_size);
     if (!m_pHeader)
       return false;
 
@@ -3005,7 +2982,6 @@ class crn_unpacker {
       const void* pSrc, uint32 src_size_in_bytes,
       void** pDst, uint32 dst_size_in_bytes, uint32 row_pitch_in_bytes,
       uint32 level_index) {
-    dst_size_in_bytes;
 
 #ifdef CRND_BUILD_DEBUG
     for (uint32 f = 0; f < m_pHeader->m_faces; f++)
@@ -3077,7 +3053,6 @@ class crn_unpacker {
 
   const uint8* m_pData;
   uint32 m_data_size;
-  crn_header m_tmp_header;
   const crn_header* m_pHeader;
 
   symbol_codec m_codec;
@@ -3198,16 +3173,16 @@ class crn_unpacker {
       for (uint32 j = 0; j < 32; j += 4)
         s ^= m_codec.decode(dm) << j;
       if (has_etc_color_blocks) {
-        for (uint32 selector = ~s & 0xAAAAAAAA | ~(s ^ s >> 1) & 0x55555555, t = 8, h = 0; h < 4; h++, t -= 15) {
+        for (uint32 selector = (~s & 0xAAAAAAAA) | (~(s ^ s >> 1) & 0x55555555), t = 8, h = 0; h < 4; h++, t -= 15) {
           for (uint32 w = 0; w < 4; w++, t += 4) {
             uint32 s0 = selector >> (w << 3 | h << 1);
-            m_color_selectors[i << 1] |= (s0 >> 1 & 1 | (s0 & 1) << 16) << (t & 15);
+            m_color_selectors[i << 1] |= ((s0 >> 1 & 1) | (s0 & 1) << 16) << (t & 15);
             uint32 s1 = selector >> (h << 3 | w << 1);
-            m_color_selectors[i << 1 | 1] |= (s1 >> 1 & 1 | (s1 & 1) << 16) << (t & 15);
+            m_color_selectors[i << 1 | 1] |= ((s1 >> 1 & 1) | (s1 & 1) << 16) << (t & 15);
           }
         }
       } else {
-        m_color_selectors[i] = (s ^ s << 1) & 0xAAAAAAAA | s >> 1 & 0x55555555;
+        m_color_selectors[i] = ((s ^ s << 1) & 0xAAAAAAAA) | (s >> 1 & 0x55555555);
       }
     }
     m_codec.stop_decoding();
@@ -3271,7 +3246,7 @@ class crn_unpacker {
     uint8 s_linear[8] = {};
     uint8* data = (uint8*)m_alpha_selectors.begin();
     for (uint i = 0; i < m_alpha_selectors.size(); i += 6, data += 12) {
-      for (uint s_group, p = 0; p < 16; p++) {
+      for (uint s_group = 0, p = 0; p < 16; p++) {
         s_group = p & 1 ? s_group >> 3 : s_linear[p >> 1] ^= m_codec.decode(dm);
         uint8 s = s_group & 7;
         if (s <= 3)
@@ -3279,13 +3254,13 @@ class crn_unpacker {
         uint8 d = 3 * (p + 1);
         uint8 byte_offset = d >> 3;
         uint8 bit_offset = d & 7;
-        data[byte_offset] |= s << 8 - bit_offset;
+        data[byte_offset] |= s << (8 - bit_offset);
         if (bit_offset < 3)
           data[byte_offset - 1] |= s >> bit_offset;
         d += 9 * ((p & 3) - (p >> 2));
         byte_offset = d >> 3;
         bit_offset = d & 7;
-        data[byte_offset + 6] |= s << 8 - bit_offset;
+        data[byte_offset + 6] |= s << (8 - bit_offset);
         if (bit_offset < 3)
           data[byte_offset + 5] |= s >> bit_offset;
       }
@@ -3573,8 +3548,8 @@ class crn_unpacker {
             endpoint_reference = buffer.endpoint_reference;
           } else {
             reference_group = m_codec.decode(m_reference_encoding_dm);
-            endpoint_reference = reference_group & 3 | reference_group >> 2 & 12;
-            buffer.endpoint_reference = reference_group >> 2 & 3 | reference_group >> 4 & 12;
+            endpoint_reference = (reference_group & 3) | (reference_group >> 2 & 12);
+            buffer.endpoint_reference = (reference_group >> 2 & 3) | (reference_group >> 4 & 12);
           }
           if (!(endpoint_reference & 3)) {
             color_endpoint_index += m_codec.decode(m_endpoint_delta_dm[0]);
@@ -3604,7 +3579,7 @@ class crn_unpacker {
             for (uint c = 0; diff && c < 3; c++)
               diff = e0[c] + 3 >= e1[c] && e1[c] + 4 >= e0[c] ? diff : 0;
             for (uint c = 0; c < 3; c++)
-              block_endpoint[c] = diff ? e0[c] << 3 | e1[c] - e0[c] & 7 : e0[c] << 3 & 0xF0 | e1[c] >> 1;
+              block_endpoint[c] = diff ? e0[c] << 3 | ((e1[c] - e0[c]) & 7) : (e0[c] << 3 & 0xF0) | e1[c] >> 1;
             block_endpoint[3] = e0[3] << 5 | e1[3] << 2 | diff << 1 | flip;
             pData[0] = *(uint32*)&block_endpoint;
             pData[1] = m_color_selectors[selector_index << 1 | flip];
@@ -3640,8 +3615,8 @@ class crn_unpacker {
             endpoint_reference = buffer.endpoint_reference;
           } else {
             reference_group = m_codec.decode(m_reference_encoding_dm);
-            endpoint_reference = reference_group & 3 | reference_group >> 2 & 12;
-            buffer.endpoint_reference = reference_group >> 2 & 3 | reference_group >> 4 & 12;
+            endpoint_reference = (reference_group & 3) | (reference_group >> 2 & 12);
+            buffer.endpoint_reference = (reference_group >> 2 & 3) | (reference_group >> 4 & 12);
           }
           if (!(endpoint_reference & 3)) {
             color_endpoint_index += m_codec.decode(m_endpoint_delta_dm[0]);
@@ -3681,7 +3656,7 @@ class crn_unpacker {
             for (uint c = 0; diff && c < 3; c++)
               diff = e0[c] + 3 >= e1[c] && e1[c] + 4 >= e0[c] ? diff : 0;
             for (uint c = 0; c < 3; c++)
-              block_endpoint[c] = diff ? e0[c] << 3 | e1[c] - e0[c] & 7 : e0[c] << 3 & 0xF0 | e1[c] >> 1;
+              block_endpoint[c] = diff ? e0[c] << 3 | ((e1[c] - e0[c]) & 7) : (e0[c] << 3 & 0xF0) | e1[c] >> 1;
             block_endpoint[3] = e0[3] << 5 | e1[3] << 2 | diff << 1 | flip;
             const uint16* pAlpha0_selectors = &m_alpha_selectors[alpha0_selector_index * 6 + (flip ? 3 : 0)];
             pData[0] = m_alpha_endpoints[alpha0_endpoint_index] | pAlpha0_selectors[0] << 16;