v2.0 Release: Added C++ Source, Compact Configs, and Improved Schedule Schema

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 *.jsonl.gz filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,4 +1,3 @@
-
 ---
 pretty_name: "LOOPerSet"
 license: "cc-by-4.0"
@@ -12,66 +11,117 @@ task_categories:
 size_categories:
 - 10M<n<100M
 configs:
+- config_name: full
+  data_files:
+  - split: train
+    path: "data/full/looperset_v2_full.jsonl.gz"
+    
+- config_name: full_compact
+  data_files:
+  - split: train
+    path: "data/full/looperset_v2_full_compact.jsonl.gz"
+
 - config_name: pact25_split
   data_files: 
   - split: train
-    path: "data/pact25_train.jsonl.gz"
+    path: "data/pact25/looperset_v2_pact_train.jsonl.gz"
   - split: validation
-    path: "data/pact25_validation.jsonl.gz"
+    path: "data/pact25/looperset_v2_pact_validation.jsonl.gz"
 
-- config_name: full
-  data_files:
+- config_name: pact25_split_compact
+  data_files: 
   - split: train
-    path: "data/looperset_full_28m.jsonl.gz"
+    path: "data/pact25/looperset_v2_pact_train_compact.jsonl.gz"
+  - split: validation
+    path: "data/pact25/looperset_v2_pact_validation_compact.jsonl.gz"
 ---
 
 # LOOPerSet: A Large-Scale Dataset for Data-Driven Polyhedral Optimization
 
-
-
 <div align="center">
 
 [![Paper](https://img.shields.io/badge/LOOPerSet_Paper-arXiv-b31b1b.svg)](https://arxiv.org/abs/2510.10209)
-[![PACT '25 Paper](https://img.shields.io/badge/LOOPer_Paper-PACT_'25-blue.svg)](https://arxiv.org/abs/2403.11522)
+[![PACT '25 Paper](https://img.shields.io/badge/LOOPer_Paper-PACT_'25-blue.svg)](https://ieeexplore.ieee.org/document/11282943)
 [![License: CC BY 4.0](https://img.shields.io/badge/License-CC--BY%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/)
 [![Dataset size](https://img.shields.io/badge/Dataset%20size-28M%20datapoints-brightgreen)]()
 
 </div>
 
 
+## Dataset at a Glance
 
-## Dataset Description
-
-`LOOPerSet` is a large-scale public dataset for machine learning-based compiler optimization. It provides labeled performance data for training and evaluating models that predict the effects of code transformations.
-
-The dataset contains over **28 million labeled data points** derived from approximately **220,000 unique, synthetically generated loop nests**. Each data point consists of a program, a specific sequence of applied loop transformations (e.g., fusion, tiling, skewing, parallelization), and its resulting ground-truth performance measurement.
-
-Transformation sequences were generated using a polyhedral compilation framework to ensure they were legal and semantics-preserving. `LOOPerSet` was originally created to train the cost model for the [LOOPer autoscheduler](https://tbd) (PACT '25). For a full description of the generation process and a diversity analysis, please see our [companion paper on arXiv](https://arxiv.org/abs/xxxx.xxxxx).
+`LOOPerSet` is a corpus of 28 million labeled compilation traces designed for machine learning research in compilers and systems. It maps synthetically generated loop nests and complex optimization sequences to ground-truth execution times measured on physical hardware. Transformation sequences were generated using a polyhedral compilation framework to ensure they were legal and semantics-preserving. 
 
+`LOOPerSet` was originally created to train the cost model for the [LOOPer autoscheduler](https://ieeexplore.ieee.org/document/11282943) (PACT '25). For a full description of the generation process and a diversity analysis, please see our [companion paper on arXiv](https://arxiv.org/abs/2510.10209).
 
-### Supported Tasks
-
-  
-The dataset can be used for several research applications in machine learning and compilers:
+### What is inside?
+Each data point represents a **(Program, Schedule) $\rightarrow$ Performance** tuple containing:
+*   **Source Code & IR:** Raw Tiramisu (C++) generator code, lowered Halide IR, and ISL ASTs.
+*   **Structured Features:** JSON-based representation of the program structure (loop hierarchy, memory access patterns, arithmetic expressions) for feature engineering.
+*   **Optimization Schedules:** Sequences of code transformations (tiling, skewing, fusion, interchange, unrolling, parallelization, etc) and the specific API commands used to apply them.
+*   **Ground Truth:** Execution time (ms) measured over many runs on physical hardware.
 
+### Key Research Tasks
+By exposing both low-level source code and high-level structural features, the dataset can be used for several research applications in machine learning and compilers:
 *   **Performance Prediction**: The dataset's primary use case.  Train a model to map a program's features and a candidate optimization schedule to a predicted performance value (e.g., execution time or speedup). This forms the core of a learned cost model for guiding compiler optimization.
 *   **Schedule Ranking**: A learning-to-rank task where a model learns to order a set of candidate schedules for a given program based on their relative performance.
 *   **Compiler Heuristic Discovery**: A data analysis task to discover new optimization heuristics by finding correlations between program features and the effectiveness of transformation sequences.
 *   **Program Representation Learning**: Develop and evaluate novel methods for featurizing programs, computer code, and transformation schedules, such as learning dense vector embeddings.
-* **Transfer Learning for Hardware Portability**: A general-purpose cost model can be pre-trained on `LOOPerSet` and then fine-tuned on a much smaller, target-specific dataset, significantly reducing the data collection cost for new architectures.
+*   **Transfer Learning**: A general-purpose cost model can be pre-trained on `LOOPerSet` and then fine-tuned on a much smaller, target-specific dataset, significantly reducing the data collection cost for new architectures.
+  
   
 ### Dataset Configurations
 
-The dataset is provided in two configurations:
+The dataset is provided in two structural variants (**Standard** and **Compact**) across two split configurations (**Full** and **PACT '25**), plus a supplementary source code archive.
 
+
+#### Variants
+*   **Standard**: Contains complete program information including raw C++ code, lowered IRs, and compile commands.  Ideal for source code analysis and NLP tasks.
+*   **Compact**: Optimized for speed and low-memory usage. It retains all features needed for training performance models but excludes raw code strings and intermediate representations. Recommended for training cost models and performance prediction.
+
+
+#### Splits
 *   **`full`**: The complete ~28 million point dataset (composed of ~220k programs), available as a single `train` split.
-*   **`pact25`** split: A 10-million-point version used to train the LOOPer cost model, pre-split into `train` (90%) and `validation` (10%) sets for reproducibility. This 10M set is a subset of the 28M one.
+*   **`pact25`** split: A 10-million-point version used to train the LOOPer cost model, pre-split into `train` (90%) and `validation` (10%) sets for reproducibility. This is a subset of the Full dataset.
+
+#### Generators Archive
+ A compressed `tar.gz` containing the raw ~220k Tiramisu C++ generator files (`.cpp`). These match the `program_name` keys in the dataset and are useful for static analysis or if you wish to re-compile/re-execute the programs yourself.
+
+#### Directory Structure
+
+```text
+data/
+├── full/
+│   ├── looperset_v2_full.jsonl.gz           (Standard)
+│   └── looperset_v2_full_compact.jsonl.gz   (Compact)
+│
+├── pact25/
+│   ├── looperset_v2_pact_train.jsonl.gz           (Standard)
+│   ├── looperset_v2_pact_train_compact.jsonl.gz   (Compact)
+│   ├── looperset_v2_pact_validation.jsonl.gz           (Standard)
+│   └── looperset_v2_pact_validation_compact.jsonl.gz   (Compact)
+│
+└── source/
+    └── looperset_v2_generators.tar.gz       (Raw C++ Generators)
+```
+
+#### File Sizes
+
+| Configuration | File Path | Compressed Size | Decompressed Size |
+| :--- | :--- | :--- | :--- |
+| **Full (Standard)** | `data/full/looperset_v2_full.jsonl.gz` | 6.0 GB | 84 GB |
+| **Full (Compact)** | `data/full/looperset_v2_full_compact.jsonl.gz` | 3.1 GB | 21 GB |
+| **PACT Train (Standard)** | `data/pact25/looperset_v2_pact_train.jsonl.gz` | 2.0 GB | 28 GB |
+| **PACT Train (Compact)** | `data/pact25/looperset_v2_pact_train_compact.jsonl.gz` | 1.1 GB | 6.8 GB |
+| **PACT Val (Standard)** | `data/pact25/looperset_v2_pact_validation.jsonl.gz` | 236 MB | 3.3 GB |
+| **PACT Val (Compact)** | `data/pact25/looperset_v2_pact_validation_compact.jsonl.gz` | 121 MB | 818 MB |
+| **Generators Source** | `data/source/looperset_v2_generators.tar.gz` | 34 MB | 339 MB |
 
 ## How to Use
 
 The dataset files are stored in  `.jsonl.gz`  format (gzipped JSON Lines), where each line is a complete JSON object representing one program.
 
-Bellow we provide a simple method to download the files and stream the data in Python.  
+Below we provide a simple method to download the files and stream the data in Python.  
 
 ### Installation
 
@@ -86,13 +136,9 @@ pip install huggingface-hub
 
 ### Step 1: Download the Data Files
 
-The dataset is available in two configurations, with the following approximate file sizes:
+The dataset is available in X configurations<....>:
+
 
-| File                          | Compressed Size | Decompressed Size |
-| ----------------------------- | --------------- | ----------------- |
-| `looperset_full.jsonl.gz`       | ~3.7 GB         | ~34 GB            |
-| `looperset_pact25_train.jsonl.gz` | ~1.2 GB         | ~22 GB            |
-| `looperset_pact25_validation.jsonl.gz` | ~146 MB         | ~5.3 GB           |
 
 First, use the `hf_hub_download` function to fetch the dataset files you need.
 
@@ -102,24 +148,24 @@ import os
 
 REPO_ID = "Mascinissa/LOOPerSet"
 
-# --- Option 1: Download the full 28M dataset ---
-full_dataset_path = hf_hub_download(
+# --- Option 1: Download the Full Compact (Recommended for Speed) ---
+full_compact_path = hf_hub_download(
     repo_id=REPO_ID,
-    filename="data/looperset_full.jsonl.gz",
+    filename="data/full/looperset_v2_full_compact.jsonl.gz",
     repo_type="dataset",
 )
-print(f"Full dataset downloaded to: {full_dataset_path}")
+print(f"Full Compact dataset downloaded to: {full_compact_path}")
 
 
-# --- Option 2: Download the PACT '25 splits ---
+# --- Option 2: Download the Standard PACT '25 splits ---
 pact25_train_path = hf_hub_download(
     repo_id=REPO_ID,
-    filename="data/pact25/looperset_pact25_train.jsonl.gz",
+    filename="data/pact25/looperset_v2_pact_train.jsonl.gz",
     repo_type="dataset",
 )
 pact25_validation_path = hf_hub_download(
     repo_id=REPO_ID,
-    filename="data/pact25/looperset_pact25_validation.jsonl.gz",
+    filename="data/pact25/looperset_v2_pact_validation.jsonl.gz",
     repo_type="dataset",
 )
 print(f"PACT'25 train split downloaded to: {pact25_train_path}")
@@ -245,7 +291,7 @@ for processed_count, program in enumerate(data_stream):
         
         if current_time < min_time:
             min_time = current_time
-            best_schedule_info = schedule['sched_str']
+            best_schedule_info = schedule['schedule_str']
 
     speedup = initial_time / min_time if min_time > 0 else float('inf')
 
@@ -283,24 +329,22 @@ Each row in the dataset represents a single synthetic program and contains all o
     "computations": { "...": "..." },
     "buffers": { "...": "..." }
   },
+  "Tiramisu_cpp": "// raw tiramisu generator source code ...",
   "initial_execution_time": 1393.751,
   "schedules_list": [
     {
-      "execution_times": [451.234, 465.112, 458.543, "..."],
-      "sched_str": "F({CO,C1},1)T2({CO},L2,L3,32,32)...",
-      "fusions": [["comp00", "comp01", 1]],
-      "tree_structure": { "..." },
-      "comp00": {
-        "tiling": {"tiling_depth": 2, "tiling_dims": ["i0", "i1"], "tiling_factors": [32, 32]},
-        "unrolling_factor": null,
-        "parallelized_dim": null,
-        "transformations_list": [ [1, 0, 1, 0, ...] ]
-      },
-      "comp01": {
-         "...": "..."
-      }
+      "transformations_list": [
+        {"type": "interchange", "loop_levels": [0,1], "parameters": [], "computations": ["comp00"]},
+        {"type": "tiling", "loop_levels": [1,2], "parameters": [32,32], "computations": ["comp01","comp02"]}
+      ],
+      "schedule_str": "I(L0,L1,comps=[comp00])|T2(L1,L2,32,32,comps=[comp02,comp02])",
+      "legacy_schedule_str": "I({C0},L0,L1)T2({C1,C2},L2,L3,32,32)...",
+      "ISL_AST": "..." ,
+      "Halide_IR": "// lowered Halide IR ...",
+      "Tiramisu_transform_commands": "comp01.tile(...); comp00.interchange(...); ...",
+      "execution_times": [451.234, 465.112, 458.543, ...]
     },
-    { "...": "..." }
+    { /* ... another schedule object ... */ }
   ]
 }
 
@@ -312,10 +356,13 @@ Each row in the dataset represents a single synthetic program and contains all o
 
 ### Top-Level Fields
 
-*   `program_name` (string): A unique identifier for the synthetic program (e.g., "function684979").
+*   `program_name` (string): A unique identifier for the synthetic program (e.g., "function684979"). This name is also used to locate the corresponding generator file in the source archive:
+  `<program_name>_generator.cpp`.
 *   `program_annotation` (dict): A detailed, structured representation of the original, untransformed program. This serves as the primary source for program feature engineering.
+*   `Tiramisu_cpp` (string): Raw Tiramisu generator C++ source code of the program before any schedule transformations. **(Excluded in Compact version)**
 *   `initial_execution_time` (float): The median execution time (in ms) of the program before any optimizations.
 *   `schedules_list` (list of dicts): A list of all optimization sequences explored for this program. Each dictionary in the list details a unique schedule and its performance.
+*   `exploration_trace` (dict): Internal search logs. **(Excluded in Compact version)**.
 
 ---
 
@@ -339,37 +386,67 @@ This object contains all the static information about the source program.
 Each element in this list represents one complete optimization schedule applied to the program.
 
 *   `execution_times` (list of float): A list of 30 raw execution time measurements (in ms) for this specific schedule. The ground-truth label for ML models is typically derived from this list (e.g., by taking the median).
-*   `sched_str` (string): A human-readable summary string of the transformations applied in this schedule (e.g., `I(L0,L1)P(L0)U(L3,8)`).
-*   `fusions` (list): A list detailing any loop fusion transformations. Each entry is a list of `[comp_1, comp_2, fusion_level]`.
-*   `tree_structure` (dict): Represents the program's loop nest structure *after* fusion has been applied.
-*   **Computation-specific transformations** (dict): For each computation in the program (e.g., `comp00`, `comp01`), there is a key holding a dictionary of the transformations applied to it:
-    *   `tiling` (dict): Details on tiling, including `tiling_depth`, `tiling_dims`, and `tiling_factors`.
-    *   `unrolling_factor` (int): The factor used for loop unrolling (if applied).
-    *   `parallelized_dim` (string): The name of the loop that was parallelized (if applied).
-    *   `transformations_list` (list):  Each element in the list is a vector representing one affine transformation (interchange, reversal, or skewing). The order of vectors defines the order of application.
+*  `transformations_list` (list of dicts): A structured list where each element describes a specific transformation step (see format below).
+*   `schedule_str` (string): A human-readable summary string of the transformations applied in this schedule (see format below).
+- `legacy_schedule_str` (string): Legacy schedule string found in older versions of the dataset. **(Excluded in Compact version)**.
+- `ISL_AST` (string): An ISL (Integer Set Library) abstract syntax tree representing the loop nest after the transformation is applied.  **(Excluded in Compact version)**.
+- `Halide_IR` (string): Generated/lowered Halide IR after applying the transformations.  **(Excluded in Compact version)**.
+- `Tiramisu_transform_commands` (string): The actual Tiramisu C++ API commands used to apply this schedule.  **(Excluded in Compact version)**.
 
 
-<details>
-<summary><b>`transformations_list` format</b></summary>
-Each element in the list is a fixed-length (16-element) integer vector representing one affine transformation. The order of vectors in the list determines the order of application.
 
-The first element of the vector (`vector[0]`) is a **`type`** tag that specifies the transformation:
-*   `1`: Loop Interchange
-*   `2`: Loop Reversal
-*   `3`: Loop Skewing
+####  Transformation Object Format (`transformations_list`)
 
-The meaning of the subsequent elements depends on the `type` tag:
+Each item in the `transformations_list` is a dictionary describing a single step:
 
-*   **If `type` is 1 (Interchange):**
-    *   `vector[1]` and `vector[2]` specify the two loop levels (as integer indices) to be interchanged. Other elements are unused.
+```json
+{
+  "type": "String",              // e.g., "skewing", "interchange", "tiling", etc.
+  "loop_levels": [Integers],      // List of loop levels involved (e.g., [0,1])
+  "parameters": [Integers],       // Numeric parameters (tiling factors, skewing coefficients)
+  "computations": ["String"]     // List of computation IDs affected
+}
+```
 
-*   **If `type` is 2 (Reversal):**
-    *   `vector[3]` specifies the loop level (as an integer index) to be reversed. Other elements are unused.
+#### Schedule String Format (`schedule_str`)
 
-*   **If `type` is 3 (Skewing):**
-    *   `vector[4]`, `vector[5]`, and `vector[6]` specify the three loop levels (as integer indices) involved in the skewing transformation.
-    *   `vector[7]` through `vector[15]` specify the nine integer parameters of the 3x3 skewing submatrix.
-</details>
+A schedule is represented as a pipe-separated list of transformations:
+
+`<T1>|<T2>|<T3>|...`
+
+Supported transformations:
+
+- `S(LX,LY,v1,v2,comps=[...])`: skewing loop levels `LX` and `LY` with factors `v1`, `v2`
+- `I(LX,LY,comps=[...])`: interchange loop levels `LX` and `LY`
+- `R(LX,comps=[...])`: reversal of loop level `LX`
+- `P(LX,comps=[...])`: parallelization of loop level `LX`
+- `T2(LX,LY,v1,v2,comps=[...])`: 2D tiling of loop levels `LX`,`LY` with factors `v1`,`v2`
+- `T3(LX,LY,LZ,v1,v2,v3,comps=[...])`: 3D tiling of loop levels `LX`,`LY`,`LZ` with factors `v1`,`v2`,`v3`
+- `U(LX,v,comps=[...])`: unrolling of loop level `LX` with factor `v`
+- `F(LX,comps=[...])`: fusion at loop level `LX` for the computations listed in `comps`
+
+
+## C++ Source Code Archive
+
+This repository also includes a compressed archive containing the raw Tiramisu generator sources for all programs (`data/looperset_generators.tar.gz`). These are provided to enable researchers to perform static program analysis, reproduce results by re-executing schedules on different hardware architectures, or extend the dataset by collecting completely new schedules.
+
+*   **Content:** Contains ~220,000 `.cpp` files.
+*   **Filename Format:** `<program_name>_generator.cpp` (e.g., `function12345_generator.cpp`).
+*   **Relation to JSON:** The content of these files is identical to the string found in the `Tiramisu_cpp` field within the JSON dataset. The archive is provided purely for convenience.
+
+**How to extract specific files in Python:**
+
+```python
+import tarfile
+
+# Extract a specific generator file
+with tarfile.open(source_code_path, "r:gz") as tar:
+    # Example: Extract function12345_generator.cpp
+    member = tar.getmember("looperset_generators/function12345_generator.cpp")
+    f = tar.extractfile(member)
+    content = f.read().decode('utf-8')
+    print(content)
+```
 
 
 ## Dataset Creation
@@ -395,7 +472,7 @@ Full details are available in our [companion paper](https://arxiv.org/abs/xxxx.x
 If you use this dataset, please cite the following paper:
 
 ```bibtex
-@misc{merouani2025looperset,
+@misc{looperset,
       title={LOOPerSet: A Large-Scale Dataset for Data-Driven Polyhedral Compiler Optimization}, 
       author={Massinissa Merouani and Afif Boudaoud and Riyadh Baghdadi},
       year={2025},
@@ -409,15 +486,15 @@ If you use this dataset, please cite the following paper:
 If you a building upon or comparing against the `LOOPer` cost model, please cite our PACT '25 paper:
 
 ```bibtex
-@misc{merouani24looper,
-      title={LOOPer: A Learned Automatic Code Optimizer For Polyhedral Compilers}, 
-      author={Massinissa Merouani and Khaled Afif Boudaoud and Iheb Nassim Aouadj and Nassim Tchoulak and Islem Kara Bernou and Hamza Benyamina and Fatima Benbouzid-Si Tayeb and Karima Benatchba and Hugh Leather and Riyadh Baghdadi},
-      year={2025},
-      eprint={2403.11522},
-      archivePrefix={arXiv},
-      primaryClass={cs.PL},
-      url={https://arxiv.org/abs/2403.11522}, 
-}
+@INPROCEEDINGS{looper,
+  author={Merouani, Massinissa and Boudaoud, Afif and Aouadj, Iheb Nassim and Tchoulak, Nassim and Bernou, Islem Kara and Benyamina, Hamza and Tayeb, Fatima Benbouzid-Si and Benatchba, Karima and Leather, Hugh and Baghdadi, Riyadh},
+  booktitle={2025 34th International Conference on Parallel Architectures and Compilation Techniques (PACT)}, 
+  title={LOOPer: A Learned Automatic Code Optimizer For Polyhedral Compilers}, 
+  year={2025},
+  pages={201-215},
+  keywords={Deep learning;Costs;Codes;Program processors;Predictive models;Space exploration;Parallel architectures;Optimization;Pluto;Faces;Compilers;Optimization;Program transformation;Machine learning;Modeling techniques},
+  doi={10.1109/PACT65351.2025.00028}}
+
 ```
 
 
@@ -426,3 +503,15 @@ If you a building upon or comparing against the `LOOPer` cost model, please cite
 
 This dataset is licensed under the [Creative Commons Attribution 4.0 International (CC-BY 4.0) License](https://creativecommons.org/licenses/by/4.0/).
 
+
+## Versioning / Changelog
+
+**v2.0  Schema Update & Compact Splits**
+*   **Source Code Availability:** Added raw Tiramisu (C++) generator code to both the JSON dataset (`Tiramisu_cpp` field) and as a standalone downloadable archive.
+*   **Compact Mode:** Introduced "Compact" dataset configurations that strip out large text fields (Source, IR, AST) to optimize for speed when training standard performance models.
+*   **Schema Update:** Completely restructured the `schedules_list`. Replaced ad-hoc lists with a structured `transformations_list` dictionary format and standardized the schedule string representation.
+*   **PACT '25 Update:** Updated citation information for the published LOOPer paper.
+
+**v1.0 (Initial Release)**
+*   Original dataset release containing ~220k programs and 28M schedules.
+*   Includes `full` and `pact25` split configurations.

data/{looperset_full.jsonl.gz → full/looperset_v2_full.jsonl.gz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5dd9c0cf6cfada7b7f9fa9715842929de856ffe6de6bff07ebd17844d5c3b8dc
-size 3934995714
+oid sha256:1f5cc4e2739018d12d01382abed7af8e07ea9d84daecd7cc3e94ed839db9151c
+size 6335196993

data/{pact25/looperset_pact25_train.jsonl.gz → full/looperset_v2_full_compact.jsonl.gz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:20ae170c1d8e9b868be6c5690f2107c26b164a1fbd68d4450bf2f8723a4336e8
-size 1309145203
+oid sha256:c881d4fe0f75ea7133e610e7d44e1f6091985e2fa5196712126e926fd306839e
+size 3239084097

data/pact25/looperset_v2_pact_train.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36919281f0e3ab633d34a08764d7efc48455f2c2ffd366799b22979d07defedb
+size 2107219002

data/pact25/looperset_v2_pact_train_compact.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4a057005df295d55c8b0dfc2dda5511ef268e2f9a48f74bc71f8bfcbcc70359
+size 1077751270

data/pact25/{looperset_pact25_validation.jsonl.gz → looperset_v2_pact_validation.jsonl.gz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:826dbc65664dfc045a417596c69d613990bffa71a3718e969e3687c1445a8cd1
-size 153532922
+oid sha256:c17d040d7db1200c5e0936f3662a6420acbcc8acfbe42b4d468713cedaff09d8
+size 247065410

data/pact25/looperset_v2_pact_validation_compact.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7324884ff762f3a9bc17c7d7bbaae72aca2fc1f7633141b4a2f694cdaf0dc622
+size 126516105

data/source/looperset_v2_generators.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36b71a62b9816a5b823239e9d81b3e4db4a3003cf45539d821e69bd1d46926cc
+size 35512759