simd-loop reference: fix description left stale by the -O2 flag change

The descriptions still read "auto-vectorization disabled", which was true when
the flags carried -fno-vectorize -fno-slp-vectorize. This PR's first commit
dropped those, so on aarch64 clang now auto-vectorizes these at -O2 and the
text contradicts the file it sits in.

Reworded to state what the build actually is -- -O2 with no -march, so baseline
NEON applies but not SVE. That is also the distinction from the autovec author,
which builds the same sources at -O3 -march=armv8.2-a+sve.

Only the description field changes; sources and compile_flags are untouched.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

solutions/simd-loop/reference/loop_001/reference_loop_001.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_001.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_001(struct loop_001_data *data) {\n    float *a = data->a;\n    float *b = data->b;\n    int n = data->n;\n    double res = 0.0;\n    for (int i = 0; i < n; i++) {\n        res += (double)a[i] * (double)b[i];\n    }\n    data->res = (float)res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_001. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_001, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_002/reference_loop_002.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_002.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_002(struct loop_002_data * input) {\n  uint32_t * a = input->a;\n  uint32_t * b = input->b;\n  int n = input->n;\n\n  uint32_t res = 0;\n  for (int i = 0; i < n; i++) {\n    res += a[i] * b[i];\n  }\n  input->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_002. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_002, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_003/reference_loop_003.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_003.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_003(struct loop_003_data * data) {\n  double * a = data->a;\n  double * b = data->b;\n  int n = data->n;\n\n  double res = 0.0;\n  for (int i = 0; i < n; i++) {\n    res += a[i] * b[i];\n  }\n  data->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_003. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_003, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_004/reference_loop_004.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_004.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_004(struct loop_004_data * data) {\n  uint64_t *a = data->a;\n  uint64_t *b = data->b;\n  int n = data->n;\n\n  uint64_t res = 0;\n  for (int i = 0; i < n; i++) {\n    res += a[i] * b[i];\n  }\n  data->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_004. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_004, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_005/reference_loop_005.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_005.h\"\n#include <cstring>\n#include <stdint.h>\n\nextern \"C\" void inner_loop_005(struct loop_005_data *data) {\n    uint8_t *p = data->p; uint8_t *lmt = data->lmt;\n    uint32_t res = 0;\n    while (p < lmt) {\n        uint32_t len = (uint32_t)strlen((const char *)p);\n        p += len + 1; res += 1; res ^= (len % 0xffff) << 16;\n    }\n    data->checksum = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_005. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_005, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_006/reference_loop_006.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_006.h\"\n#include <cstring>\n#include <stdint.h>\n\nextern \"C\" void inner_loop_006(struct loop_006_data *data) {\n    uint8_t *p = data->p; uint8_t *lmt = data->lmt;\n    uint32_t res = 0;\n    while (p < lmt) {\n        uint32_t len = (uint32_t)strlen((const char *)p);\n        p += len + 1; res += 1; res ^= (len % 0xffff) << 16;\n    }\n    data->checksum = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_006. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_006, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_008/reference_loop_008.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_008.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_008(struct loop_008_data * data) {\n  double *a = data->a;\n  int n = data->n;\n  double res = 0.0;\n  for (int i = 0; i < n; i++) {\n    res += a[i];\n  }\n  data->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_008. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_008, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_010/reference_loop_010.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_010.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_010(struct loop_010_data * data) {\n  float *a = data->a;\n  uint64_t n = data->n;\n\n  bool any = 0;\n  bool all = 1;\n\n  for (int i = 0; i < n; i++) {\n    if (a[i] < 0.0f) {\n      any = 1;\n    } else {\n      all = 0;\n    }\n  }\n  data->res = all ? 1 : any ? 2 : 3;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_010. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_010, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_024/reference_loop_024.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_024.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_024(struct loop_024_data * data) {\n  uint8_t * a = data->a;\n  uint8_t * b = data->b;\n  int64_t n = data->n;\n\n  uint32_t sum = 0;\n  for (int i = 0; i < n; i++) {\n    sum += __builtin_abs(a[i] - b[i]);\n  }\n  data->res = sum;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_024. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_024, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_027/reference_loop_027.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_027.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_027(struct loop_027_data * data) {\n  float *input = data->input;\n  float *output = data->output;\n  int64_t size = data->size;\n\n  for (int64_t i = 0; i < size; i++) {\n    output[i] = __builtin_sqrtf(input[i]);\n  }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_027. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_027, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_028/reference_loop_028.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_028.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_028(struct loop_028_data * data) {\n  double * input1 = data->input1;\n  double * input2 = data->input2;\n  double * output = data->output;\n  int64_t size = data->size;\n\n  for (int64_t i = 0; i < size; i++) {\n    output[i] = input1[i] / input2[i];\n  }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_028. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_028, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_029/reference_loop_029.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_029.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_029(struct loop_029_data * data) {\n  double *input = data->input;\n  int64_t *scale = data->scale;\n  double *output = data->output;\n  int64_t size = data->size;\n\n  for (int64_t i = 0; i < size; i++) {\n    output[i] = __builtin_scalbn(input[i], (int)scale[i]);\n  }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_029. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_029, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_032/reference_loop_032.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_032.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_032(struct loop_032_data * input) {\n  double *a = input->a;\n  double *b = input->b;\n  int n = input->n;\n\n  double res = 0.0;\n  int lw = 0;\n  for (int j = 4; j < n; j = j + 5) {\n    res -= a[lw] * b[j];\n    lw++;\n  }\n  input->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_032. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_032, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_033/reference_loop_033.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_033.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_033(struct loop_033_data * input) {\n  double *a = input->a;\n  double *b = input->b;\n  int64_t n = input->n;\n\n  double res = 0.0;\n  for (int i = 0; i < n; i++) {\n    res += a[i] * b[i];\n  }\n  input->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_033. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_033, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_034/reference_loop_034.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_034.h\"\n#include <cstring>\n#include <stdint.h>\n\nextern \"C\" void inner_loop_034(struct loop_034_data *data) {\n    uint8_t *p1 = data->a; uint8_t *p2 = data->b; uint8_t *lmt = data->lmt;\n    uint32_t res = 0, cnt = 0; int length = 13;\n    while (p1 < lmt) {\n        int64_t r = strcmp((const char *)p1, (const char *)p2);\n        uint32_t cmp = 1; if (r > 0) cmp = 2; if (r < 0) cmp = 3;\n        res += cnt * cmp; p1 += length; p2 += length; cnt++;\n        length = 3 + (length + 11) % 43;\n    }\n    data->checksum = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_034. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_034, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_035/reference_loop_035.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_035.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_035(struct loop_035_data * input) {\n  float * a = input->a;\n  float * b = input->b;\n  float * c = input->c;\n  int64_t n = input->n;\n\n  for (int64_t i = 0; i < n; i++) {\n    c[i] = a[i] + b[i];\n  }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_035. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_035, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_037/reference_loop_037.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_037.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_037(struct loop_037_data *data) {\n    cfloat32_t *a = data->a0; cfloat32_t *b = data->b0; cfloat32_t *c = data->c0;\n    uint64_t size = data->size;\n    for (uint64_t i = 0; i < size; i++) {\n        c[i].re = (a[i].re * b[i].re) - (a[i].im * b[i].im);\n        c[i].im = (a[i].re * b[i].im) + (a[i].im * b[i].re);\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_037. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_037, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_038/reference_loop_038.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_038.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_038(struct loop_038_data *data) {\n    _Float16 *a = data->a;\n    _Float16 *b = data->b;\n    _Float16 *c = data->c;\n    int dim = data->dim;\n    _Float16 k = (_Float16)0.25f;\n    for (int row = 0; row < dim - 1; row++) {\n        for (int col = 0; col < dim - 1; col++) {\n            _Float16 s0 = a[row * dim + col];\n            _Float16 s1 = a[row * dim + col + 1];\n            _Float16 s2 = a[(row + 1) * dim + col];\n            _Float16 s3 = a[(row + 1) * dim + col + 1];\n            _Float16 ac = b[row * dim + col];\n            c[row * dim + col] = ac + s0 * k + s1 * k + s2 * k + s3 * k;\n        }\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_038. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_038, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_101/reference_loop_101.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_101.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_101(struct loop_101_data *data) {\n    uint8_t *a = data->a;\n    uint8_t *b = data->b;\n    int n = data->n;\n    for (int i = 0; i < n - 1; i++) {\n        uint16_t s1 = b[i];\n        uint16_t s2 = b[i + 1];\n        a[2 * i]     = (3 * s1 + s2 + 2) >> 2;\n        a[2 * i + 1] = (3 * s2 + s1 + 2) >> 2;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_101. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_101, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_102/reference_loop_102.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_102.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_102(struct loop_102_data *data) {\n    uint32_t *histogram = data->histogram;\n    uint64_t histogram_size = data->histogram_size;\n    uint32_t *records = data->records;\n    int64_t num_records = data->num_records;\n    for (uint64_t i = 0; i < histogram_size; i++) histogram[i] = 0;\n    for (int64_t i = 0; i < num_records; i++) histogram[records[i]] += 1;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_102. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_102, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_103/reference_loop_103.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_103.h\"\n#include <stdint.h>\n\nstatic uint8_t *skip_ws(uint8_t *p, uint8_t *end) {\n    while (p != end && (*p == ' ' || *p == '\\n' || *p == '\\r' || *p == '\\t')) p++;\n    return p;\n}\nstatic uint8_t *skip_wd(uint8_t *p, uint8_t *end) {\n    while (p != end && *p != ' ' && *p != '\\n' && *p != '\\r' && *p != '\\t') p++;\n    return p;\n}\nextern \"C\" void inner_loop_103(struct loop_103_data *data) {\n    uint8_t *p = data->p; uint8_t *end = data->end;\n    int count = 0;\n    p = skip_ws(p, end);\n    while (p != end) { count++; p = skip_wd(p, end); p = skip_ws(p, end); }\n    data->checksum = count;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_103. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_103, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_104/reference_loop_104.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_104.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_104(struct loop_104_data *data) {\n    uint32_t *histogram = data->histogram;\n    uint64_t histogram_size = data->histogram_size;\n    uint8_t *d = data->data;\n    int n = data->n;\n    for (uint64_t i = 0; i < histogram_size; i++) histogram[i] = 0;\n    for (int i = 0; i < n; i++) histogram[d[i]] += 1;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_104. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_104, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_105/reference_loop_105.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_105.h\"\n\nextern \"C\" void inner_loop_105(struct loop_105_data *data) {\n    float *a = data->a;\n    int n = data->n;\n    double res = 0.0;\n    for (int i = 0; i < n; i++) res += (double)a[i];\n    data->res = (float)res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_105. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_105, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_106/reference_loop_106.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_106.h\"\n#include <stdint.h>\n\nstatic uint32_t popcount106(uint32_t x) {\n    x = (x & 0x55555555u) + ((x >> 1) & 0x55555555u);\n    x = (x & 0x33333333u) + ((x >> 2) & 0x33333333u);\n    x = (x & 0x0F0F0F0Fu) + ((x >> 4) & 0x0F0F0F0Fu);\n    x = (x & 0x00FF00FFu) + ((x >> 8) & 0x00FF00FFu);\n    x = (x & 0x0000FFFFu) + ((x >> 16) & 0x0000FFFFu);\n    return x;\n}\nstatic uint32_t compress106(uint32_t x, uint32_t m) {\n    uint32_t mk, mp, mv, t;\n    x = x & m;\n    mk = ~m << 1;\n    for (int i = 0; i < 5; i++) {\n        mp = mk ^ (mk << 1);\n        mp = mp ^ (mp << 2);\n        mp = mp ^ (mp << 4);\n        mp = mp ^ (mp << 8);\n        mp = mp ^ (mp << 16);\n        mv = mp & m;\n        m = (m ^ mv) | (mv >> (1 << i));\n        t = x & mv;\n        x = (x ^ t) | (t >> (1 << i));\n        mk = mk & ~mp;\n    }\n    return x;\n}\nstatic uint32_t sag106(uint32_t x, uint32_t m) {\n    return (compress106(x, m) << popcount106(m)) | compress106(x, ~m);\n}\nstatic uint32_t permute106(uint32_t x, uint32_t p[5]) {\n    x = sag106(x, p[0]);\n    x = sag106(x, p[1]);\n    x = sag106(x, p[2]);\n    x = sag106(x, p[3]);\n    return sag106(x, p[4]);\n}\nextern \"C\" void inner_loop_106(struct loop_106_data *data) {\n    uint32_t *a = data->a;\n    uint32_t *b = data->b;\n    int64_t n = data->n;\n    uint32_t permutation[5] = {0xaaaaaaaau, 0xccccccccu, 0x0f0f0f0fu, 0x0ff00ff0u, 0x0ffff000u};\n    uint32_t p[5];\n    p[0] = permutation[0];\n    p[1] = sag106(permutation[1], permutation[0]);\n    p[2] = sag106(permutation[2], permutation[0]);\n    p[3] = sag106(permutation[3], permutation[0]);\n    p[4] = sag106(permutation[4], permutation[0]);\n    for (int64_t i = 0; i < n; i++) b[i] = permute106(a[i], p);\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_106. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_106, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_108/reference_loop_108.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_108.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_108(struct loop_108_data *data) {\n    uint32_t *rgba = data->rgba;\n    uint8_t *y = data->y;\n    int64_t n = data->n;\n    for (int64_t i = 0; i < n; i++) {\n        y[i] = (rgba[i] >> 24) >> 2;\n        y[i] += ((rgba[i] >> 16) & 0xff) >> 1;\n        y[i] += ((rgba[i] >> 16) & 0xff) >> 3;\n        y[i] += ((rgba[i] >> 8) & 0xff) >> 3;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_108. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_108, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_109/reference_loop_109.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_109.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_109(struct loop_109_data *data) {\n    cuint32_t *a = data->a0; cuint32_t *b = data->b0; cuint32_t *c = data->c0;\n    uint64_t size = data->size;\n    for (uint64_t i = 0; i < size; i++) {\n        c[i].re = a[i].re - b[i].im;\n        c[i].im = a[i].im + b[i].re;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_109. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_109, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_110/reference_loop_110.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_110.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_110(struct loop_110_data *data) {\n    cint8_t *a = data->a0; cint8_t *b = data->b0; cint32_t *c = data->c0;\n    uint64_t size = data->size;\n    for (uint64_t i = 0; i < size; i++) {\n        c[i].re = (int32_t)(((a[2*i].re * b[2*i].re) - (a[2*i].im * b[2*i].im)) +\n                            ((a[2*i+1].re * b[2*i+1].re) - (a[2*i+1].im * b[2*i+1].im)));\n        c[i].im = (int32_t)(((a[2*i].im * b[2*i].re) + (a[2*i].re * b[2*i].im)) +\n                            ((a[2*i+1].im * b[2*i+1].re) + (a[2*i+1].re * b[2*i+1].im)));\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_110. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_110, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_112/reference_loop_112.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_112.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_112(struct loop_112_data *data) {\n    cuint32_t *a = data->a0; cuint32_t *b = data->b0; cuint32_t *c = data->c0;\n    uint64_t size = data->size;\n    for (uint64_t i = 0; i < size; i++) {\n        c[i].re = (a[i].re * b[i].re) - (a[i].im * b[i].im);\n        c[i].im = (a[i].re * b[i].im) + (a[i].im * b[i].re);\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_112. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_112, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_113/reference_loop_113.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_113.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_113(struct loop_113_data * input) {\n  uint32_t * a = input->a0;\n  uint32_t * b = input->b0;\n  uint32_t * c = input->c0;\n  uint64_t size = input->size;\n\n  uint64_t i;\n\n  for (i = 0; i < size; i += 2) {\n    c[i] = a[i] + a[i + 1];\n    c[i + 1] = b[i] + b[i + 1];\n  }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_113. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_113, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_114/reference_loop_114.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_114.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_114(struct loop_114_data *data) {\n    int16_t *d = data->data;\n    int16_t *res = data->res;\n    int32_t n = data->n;\n    int32_t lags = data->lags;\n    int16_t scale = data->scale;\n    for (int lag = 0; lag < lags; lag++) {\n        int32_t acc = 0;\n        int lmt = n - lag;\n        for (int i = 0; i < lmt; i++)\n            acc += ((int32_t)d[i] * (int32_t)d[i + lag]) >> scale;\n        res[lag] = (int16_t)(acc >> 16);\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_114. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_114, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_120/reference_loop_120.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_120.h\"\n#include <algorithm>\n\nextern \"C\" void inner_loop_120(struct loop_120_data *data) {\n    std::sort(data->data, data->data + data->n);\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_120. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_120, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_121/reference_loop_121.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_121.h\"\n#include <algorithm>\n\nextern \"C\" void inner_loop_121(struct loop_121_data *data) {\n    std::sort(data->data, data->data + data->n);\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_121. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_121, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_122/reference_loop_122.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_122.h\"\n#include <algorithm>\n\nextern \"C\" void inner_loop_122(struct loop_122_data *data) {\n    std::sort(data->data, data->data + data->n);\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_122. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_122, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_123/reference_loop_123.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_123.h\"\n#include <algorithm>\n\nextern \"C\" void inner_loop_123(struct loop_123_data *data) {\n    std::sort(data->data, data->data + data->n);\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_123. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_123, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_124/reference_loop_124.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_124.h\"\n#include <algorithm>\n\nextern \"C\" void inner_loop_124(struct loop_124_data *data) {\n    std::sort(data->data, data->data + data->n);\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_124. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_124, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_126/reference_loop_126.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_126.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_126(struct loop_126_data * data) {\n  uint32_t *a = data->a;\n  uint32_t *b = data->b;\n  int n = data->n;\n\n  uint32_t res = 0;\n  for (int i = 0; i < n; i++) {\n    res += a[i] * b[i];\n    if (res % 2) {\n      res++;\n    }\n  }\n  data->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_126. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_126, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_127/reference_loop_127.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_127.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_127(struct loop_127_data * data) {\n  uint32_t *a = data->a;\n  uint32_t *b = data->b;\n  int n = data->n;\n\n  uint32_t res = 0;\n  for (int i = 0; i < n; i++) {\n    res += a[i] * b[i];\n    if (a[i] == 512) {\n      break;\n    }\n  }\n  data->res = res;\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_127. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_127, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_128/reference_loop_128.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_128.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_128(struct loop_128_data * data) {\n  uint32_t *a = data->a;\n  uint32_t *b = data->b;\n  uint32_t *c = data->c;\n  int n = data->n;\n\n  for (int i = 0; i < n; i++) {\n    c[i] = a[i] + b[i];\n  }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_128. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_128, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_130/reference_loop_130.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_130.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_130(struct loop_130_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    uint64_t k = data->k;\n    float *a = data->a;\n    float *b = data->b;\n    float *c = data->c;\n    for (uint64_t y = 0; y < m; y++) {\n        for (uint64_t x = 0; x < n; x++) {\n            float d = 0;\n            for (uint64_t z = 0; z < k; z++) d += a[y * k + z] * b[z * n + x];\n            c[y * n + x] = d;\n        }\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_130. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_130, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_135/reference_loop_135.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_135.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_135(struct loop_135_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    uint64_t k = data->k;\n    int8_t *a = data->a;\n    int8_t *b = data->b;\n    int32_t *c = data->c;\n    for (uint64_t x = 0; x < m; x++) {\n        for (uint64_t y = 0; y < n; y++) {\n            int32_t acc = 0;\n            for (uint64_t z = 0; z < k; z++)\n                acc += (int32_t)a[x * k + z] * (int32_t)b[z * n + y];\n            c[x * n + y] = acc;\n        }\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_135. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_135, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_216/reference_loop_216.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_216.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_216(struct loop_216_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    float *a = data->a;\n    float *x = data->x;\n    float *b = data->b;\n    for (uint64_t i = 0; i < m; i++) {\n        float d = 0;\n        for (uint64_t j = 0; j < n; j++) d += a[(m * j) + i] * x[j];\n        b[i] = d;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_216. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_216, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_217/reference_loop_217.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_217.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_217(struct loop_217_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    uint8_t *a = data->a;\n    uint8_t *b = data->b;\n    uint32_t *c = data->c;\n    for (uint64_t y = 0; y < m; y++) {\n        uint32_t d = 0;\n        for (uint64_t x = 0; x < n; x++) d += (uint32_t)a[y * n + x] * (uint32_t)b[x];\n        c[y] = d;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_217. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_217, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_218/reference_loop_218.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_218.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_218(struct loop_218_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    double *a = data->a;\n    double *x = data->x;\n    double *b = data->b;\n    for (uint64_t i = 0; i < m; i++) {\n        double d = 0;\n        for (uint64_t j = 0; j < n; j++) d += a[(m * j) + i] * x[j];\n        b[i] = d;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_218. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_218, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_219/reference_loop_219.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_219.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_219(struct loop_219_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    uint8_t *a = data->a;\n    uint8_t *b = data->b;\n    uint32_t *c = data->c;\n    for (uint64_t y = 0; y < m; y++) {\n        uint32_t d = 0;\n        for (uint64_t x = 0; x < n; x++) d += (uint32_t)a[x * m + y] * (uint32_t)b[x];\n        c[y] = d;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_219. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_219, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_220/reference_loop_220.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_220.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_220(struct loop_220_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    float *a = data->a;\n    float *x = data->x;\n    float *b = data->b;\n    for (uint64_t i = 0; i < m; i++) {\n        float d = 0;\n        for (uint64_t j = 0; j < n; j++) d += a[(i * n) + j] * x[j];\n        b[i] = d;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_220. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_220, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_221/reference_loop_221.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_221.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_221(struct loop_221_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    double *a = data->a;\n    double *x = data->x;\n    double *b = data->b;\n    for (uint64_t i = 0; i < m; i++) {\n        double d = 0;\n        for (uint64_t j = 0; j < n; j++) d += a[(i * n) + j] * x[j];\n        b[i] = d;\n    }\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_221. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_221, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }

solutions/simd-loop/reference/loop_223/reference_loop_223.json

@@ -31,5 +31,5 @@
       "content": "#include \"loop_223.h\"\n#include <stdint.h>\n\nextern \"C\" void inner_loop_223(struct loop_223_data *data) {\n    uint64_t m = data->m;\n    uint64_t n = data->n;\n    uint32_t *a = data->a;\n    uint32_t *at = data->at;\n    for (uint64_t i = 0; i < m; i++)\n        for (uint64_t j = 0; j < n; j++)\n            at[j * m + i] = a[i * n + j];\n}\n"
     }
   ],
-  "description": "Scalar reference (auto-vectorization disabled) for loop_223. Baseline for speedup measurement."
+  "description": "Scalar reference for loop_223, built at -O2 with no -march (baseline NEON auto-vectorization applies; no SVE). Baseline for speedup measurement."
 }